{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4a99dc10",
   "metadata": {},
   "source": [
    "### 初始化环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f67fe74b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 在jupyter notebook里env.render看不到窗口\n",
    "# 写一个helper类，用matplotlib刷新显示图像\n",
    "# 初始化传入env，调用helper的render即可\n",
    "from IPython import display # 导入display模块，用于在Jupyter Notebook中显示图像\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt # 导入matplotlib库，用于绘制图像\n",
    "%matplotlib inline\n",
    "\n",
    "class GymHelper:\n",
    "    def __init__(self, env, figsize = (3, 3)):\n",
    "        self.env = env # 初始化Gym环境\n",
    "        self.figsize = figsize # 初始化绘图窗口大小\n",
    "        \n",
    "        plt.figure(figsize = figsize) # 创建绘图窗口\n",
    "        plt.title(self.env.spec.id) # 标题设为环境名\n",
    "        self.img = plt.imshow(env.render()) # 在绘图窗口中显示初始图像\n",
    "    \n",
    "    def render(self, title = None):\n",
    "        image_data = self.env.render() # 获取当前环境图像渲染数据\n",
    "        \n",
    "        self.img.set_data(image_data) # 更新绘图窗口中的图像数据\n",
    "        display.display(plt.gcf()) # 刷新显示\n",
    "        display.clear_output(wait = True) # 有新图片时再清除绘图窗口原有图像\n",
    "        if title: # 如果有标题，就显示标题\n",
    "            plt.title(title)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "713ab4b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 导入gym库\n",
    "import gym\n",
    "\n",
    "# 创建环境，指定渲染模式为rgb_array，如果是在IDE中可以改为'human'\n",
    "env = gym.make('Acrobot-v1', render_mode='rgb_array')\n",
    "# 重置环境\n",
    "env.reset()\n",
    "# 创建GymHelper\n",
    "gym_helper = GymHelper(env)\n",
    "\n",
    "# 循环N次\n",
    "for i in range(20):\n",
    "    gym_helper.render(title = str(i)) # 渲染环境\n",
    "    action = env.action_space.sample() # 从动作空间中随机选取一个动作\n",
    "    observation, reward, terminated, truncated, info = env.step(action) # 执行动作\n",
    "    if terminated or truncated: # 如果游戏结束，则结束循环\n",
    "        break\n",
    "\n",
    "# 游戏结束\n",
    "gym_helper.render(title = \"Finished\")\n",
    "# 关闭环境\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e470bd0",
   "metadata": {},
   "source": [
    "环境介绍 https://www.gymlibrary.dev/environments/classic_control/acrobot/"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a2b64ac",
   "metadata": {},
   "source": [
    "### PPO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a20b13d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入必要的库\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import numpy as np\n",
    "import sys\n",
    "import time\n",
    "import random\n",
    "import collections\n",
    "from tqdm import * # 用于显示进度条\n",
    "\n",
    "# 策略模型，给定状态生成各个动作的概率\n",
    "class PolicyModel(nn.Module):\n",
    "    def __init__(self, input_dim, output_dim):\n",
    "        super(PolicyModel, self).__init__()\n",
    "        \n",
    "        # 使用全连接层构建一个简单的神经网络，ReLU作为激活函数\n",
    "        # 最后加一个Softmax层，使得输出可以看作是概率分布\n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Linear(input_dim, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, output_dim),\n",
    "            nn.Softmax(dim = 1)\n",
    "        )\n",
    "\n",
    "    # 定义前向传播，输出动作概率分布\n",
    "    def forward(self, x):\n",
    "        action_prob = self.fc(x)\n",
    "        return action_prob\n",
    "\n",
    "# 价值模型，给定状态估计价值\n",
    "class ValueModel(nn.Module):\n",
    "    def __init__(self, input_dim):\n",
    "        super(ValueModel, self).__init__()\n",
    "        \n",
    "        # 网络结构和策略模型类似，但是输出层只有一个节点\n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Linear(input_dim, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 1)\n",
    "        )\n",
    "\n",
    "    # 定义前向传播，输出价值估计\n",
    "    def forward(self, x):\n",
    "        value = self.fc(x)\n",
    "        return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bb8919f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义PPO类\n",
    "class PPO:\n",
    "    # 构造函数，参数包含环境，学习率，折扣因子，优势计算参数，clip参数，训练轮数\n",
    "    def __init__(self, env, learning_rate=0.001, gamma=0.99, lamda=0.95, clip_eps=0.2, epochs=10):\n",
    "        self.env = env\n",
    "        self.gamma = gamma\n",
    "        self.lamda = lamda\n",
    "        self.clip_eps = clip_eps\n",
    "        self.epochs = epochs\n",
    "\n",
    "        # 判断可用的设备是 CPU 还是 GPU\n",
    "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "        # 根据环境的观测空间和动作空间，定义策略模型和价值模型，并将模型移动到指定设备上\n",
    "        self.policy_model = PolicyModel(env.observation_space.shape[0], env.action_space.n).to(self.device)\n",
    "        self.value_model = ValueModel(env.observation_space.shape[0]).to(self.device)\n",
    "\n",
    "        # 定义Adam优化器\n",
    "        self.policy_optimizer = torch.optim.Adam(self.policy_model.parameters(), lr=learning_rate)\n",
    "        self.value_optimizer = torch.optim.Adam(self.value_model.parameters(), lr=learning_rate)\n",
    "    \n",
    "    # 使用策略模型生成动作概率分布并采样\n",
    "    def choose_action(self, state):\n",
    "        # 将状态转换为tensor输入模型\n",
    "        state = torch.FloatTensor(np.array([state])).to(self.device)\n",
    "        with torch.no_grad():\n",
    "            action_prob = self.policy_model(state)\n",
    "        \n",
    "        # 生成分布后采样返回动作\n",
    "        c = torch.distributions.Categorical(action_prob)\n",
    "        action = c.sample()\n",
    "        return action.item()\n",
    "    \n",
    "    # 广义优势估计\n",
    "    def calc_advantage(self, td_delta):\n",
    "        # 将TD误差转换为numpy数组\n",
    "        td_delta = td_delta.cpu().detach().numpy()\n",
    "        # 初始化优势函数值及存储优势值的列表\n",
    "        advantage = 0\n",
    "        advantage_list = []\n",
    "        # 反向遍历，从最后一步开始倒推\n",
    "        for r in td_delta[::-1]:\n",
    "            # 将当前步的TD误差及上一步优势加权值作为当前步的优势\n",
    "            advantage = r + self.gamma * self.lamda * advantage\n",
    "            # 将优势值加到列表开头，最终得到顺序序列\n",
    "            advantage_list.insert(0, advantage)\n",
    "        # 转换为tensor后返回\n",
    "        return torch.FloatTensor(np.array(advantage_list)).to(self.device)\n",
    "    \n",
    "    # 模型更新\n",
    "    def update(self, buffer):\n",
    "        # 取出数据，并将其转换为numpy数组\n",
    "        # 然后进一步转换为tensor，并将数据转移到指定计算资源设备上\n",
    "        states, actions, rewards, next_states, dones = zip(*buffer)\n",
    "        states = torch.FloatTensor(np.array(states)).to(self.device)\n",
    "        actions = torch.tensor(np.array(actions)).view(-1, 1).to(self.device)\n",
    "        rewards = torch.FloatTensor(np.array(rewards)).view(-1, 1).to(self.device)\n",
    "        next_states = torch.FloatTensor(np.array(next_states)).to(self.device)\n",
    "        dones = torch.FloatTensor(np.array(dones)).view(-1, 1).to(self.device)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            # 计算旧策略下的动作概率\n",
    "            old_action_prob = torch.log(self.policy_model(states).gather(1, actions))\n",
    "            \n",
    "            # 计算TD目标及误差\n",
    "            td_target = rewards + (1 - dones) * self.gamma * self.value_model(next_states)\n",
    "            td_delta = td_target - self.value_model(states)\n",
    "        \n",
    "        # 优势估计\n",
    "        advantage = self.calc_advantage(td_delta)\n",
    "        \n",
    "        # 多步更新策略\n",
    "        for i in range(self.epochs):\n",
    "            # 计算新策略下的动作概率\n",
    "            action_prob = torch.log(self.policy_model(states).gather(1, actions))\n",
    "            # 计算策略动作概率比\n",
    "            ratio = torch.exp(action_prob - old_action_prob)\n",
    "            \n",
    "            # CLIP修剪\n",
    "            part1 = ratio * advantage\n",
    "            part2 = torch.clamp(ratio, 1 - self.clip_eps, 1 + self.clip_eps) * advantage\n",
    "            # 计算策略损失\n",
    "            policy_loss = -torch.min(part1, part2).mean()\n",
    "            # 计算价值损失\n",
    "            value_loss = F.mse_loss(self.value_model(states), td_target).mean()\n",
    "            \n",
    "            # 梯度清零、反向传播、更新参数\n",
    "            self.policy_optimizer.zero_grad()\n",
    "            self.value_optimizer.zero_grad()\n",
    "            policy_loss.backward()\n",
    "            value_loss.backward()\n",
    "            self.policy_optimizer.step()\n",
    "            self.value_optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "58d673b2",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 0: -500.0                      \n",
      "Episode 30: -258.0                              \n",
      "Episode 60: -216.0                              \n",
      "Episode 90: -92.0                               \n",
      "Episode 120: -77.0                               \n",
      "Episode 150: -77.0                               \n",
      "Episode 180: -85.0                               \n",
      "Episode 210: -77.0                               \n",
      "Episode 240: -93.0                               \n",
      "Episode 270: -80.0                               \n",
      "100%|██████████| 300/300 [00:17<00:00, 17.50it/s]\n"
     ]
    }
   ],
   "source": [
    "# 定义超参数\n",
    "max_episodes = 300 # 训练episode数\n",
    "max_steps = 500 # 每个回合的最大步数\n",
    "\n",
    "# 创建PPO对象\n",
    "agent = PPO(env)\n",
    "# 定义保存每个回合奖励的列表\n",
    "episode_rewards = []\n",
    "\n",
    "# 开始循环，tqdm用于显示进度条并评估任务时间开销\n",
    "for episode in tqdm(range(max_episodes), file=sys.stdout):\n",
    "    # 重置环境并获取初始状态\n",
    "    state, _ = env.reset()\n",
    "    # 当前回合的奖励\n",
    "    episode_reward = 0\n",
    "    # 记录每个episode的信息\n",
    "    buffer = []\n",
    "\n",
    "    # 循环进行每一步操作\n",
    "    for step in range(max_steps):\n",
    "        # 根据当前状态选择动作\n",
    "        action = agent.choose_action(state)\n",
    "        # 执行动作，获取新的信息\n",
    "        next_state, reward, terminated, truncated, info = env.step(action)\n",
    "        # 判断是否达到终止状态\n",
    "        done = terminated or truncated\n",
    "        \n",
    "        # 将这个五元组加到buffer中\n",
    "        buffer.append((state, action, reward, next_state, done))\n",
    "        # 累计奖励\n",
    "        episode_reward += reward\n",
    "        \n",
    "        # 更新当前状态\n",
    "        state = next_state\n",
    "\n",
    "        if done:\n",
    "            break\n",
    "    \n",
    "    # 更新策略\n",
    "    agent.update(buffer)\n",
    "    # 记录当前回合奖励值\n",
    "    episode_rewards.append(episode_reward)\n",
    "    \n",
    "    # 打印中间值\n",
    "    if episode % (max_episodes // 10) == 0:\n",
    "        tqdm.write(\"Episode \" + str(episode) + \": \" + str(episode_reward))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "410fa6ed",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAGxCAYAAACXwjeMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACWgklEQVR4nO2deXwb9Zn/P6PTR2zHiZ04zp3QUCAcIeEIR0OAAC3QsixtgZYf2bbsUkrZNvSCtlxtoN0Fdre0pQdt6UGXdhdod6F0E0IIUAKEECAhhBByH44TJ/FtSZbm98fo+53vXNLIkmxZ/rzzysuyNJJGo/HMZ57n8zyPpuu6DkIIIYSQYUpgqFeAEEIIISQfKGYIIYQQMqyhmCGEEELIsIZihhBCCCHDGooZQgghhAxrKGYIIYQQMqyhmCGEEELIsIZihhBCCCHDGooZQgghhAxrKGYIIcQHzz33HDRNw3PPPTfUq0IIsUExQwghhJBhDcUMIWTQ6OnpGepVyEhvb+9QrwIhZABQzBBCisIdd9wBTdPw+uuv44orrkB9fT1mzpwJXdfx4x//GCeddBIqKytRX1+PK664Alu3bpXP/dGPfoRAIIDW1lZ533333QdN0/CFL3xB3pdKpVBfX4+bb75Z3nfnnXfitNNOw5gxY1BbW4uTTz4Zv/jFL2CfqTtt2jRccsklePzxxzFnzhxUVFTgzjvvBABs2rQJF110EaqqqtDQ0IDrr78enZ2dxdpUhJA8CQ31ChBCypvLL78cV155Ja6//np0d3fjn/7pn/Dwww/jpptuwve//30cOnQId911F8444wy8+eabGD9+PM4//3zouo4VK1bgqquuAgA888wzqKysxPLly+Vrv/baazhy5AjOP/98ed/27dvxT//0T5gyZQoA4OWXX8YXv/hF7NmzB7fddptl3V5//XW88847+Na3voXp06ejuroa+/fvx4IFCxAOh/HjH/8Y48ePxyOPPIIbb7xxELYWIWRA6IQQUgRuv/12HYB+2223yftWr16tA9Dvu+8+y7K7du3SKysr9a997WvyvkmTJumf+cxndF3X9VgspldXV+tf//rXdQD6jh07dF3X9aVLl+rhcFjv6upyXYdkMqknEgn9rrvu0seOHaunUin52NSpU/VgMKi/++67lud8/etf1zVN09944w3L/YsWLdIB6CtXrsx9YxBCigrTTISQovL3f//38vaTTz4JTdPw6U9/Gv39/fJ/U1MTTjzxREul0HnnnYdnnnkGAPDSSy+hp6cHS5YsQUNDg4zOPPPMM5g/fz6qq6vl85599lmcf/75qKurQzAYRDgcxm233Ya2tjZL2goATjjhBMyaNcty38qVK3HcccfhxBNPtNx/9dVXF2R7EEIKD8UMIaSoTJgwQd7ev38/dF3H+PHjEQ6HLf9ffvllHDx4UC57/vnnY+fOnXjvvffwzDPPYM6cORg3bhzOPfdcPPPMM+jt7cVLL71kSTG9+uqruOCCCwAAP//5z/G3v/0Na9aswTe/+U0AToOvum6CtrY2NDU1Oe53u48QUhrQM0MIKSqapsnbDQ0N0DQNL7zwAqLRqGNZ9b7zzjsPgBF9Wb58ORYtWiTv/9a3voXnn38esVjMImYeffRRhMNhPPnkk6ioqJD3/+lPf8q6boKxY8eipaXFcb/bfYSQ0oCRGULIoHHJJZdA13Xs2bMH8+bNc/w//vjj5bITJkzAsccei8ceewxr166VYmbRokU4cOAA7r//ftTW1uKUU06Rz9E0DaFQCMFgUN7X29uL3/72t77XceHChXj77bfx5ptvWu7//e9/P9CPTQgpMhQzhJBB48wzz8Q//uM/4h/+4R/wta99DU8++SRWrlyJ3//+97jhhhvw4IMPWpY/77zzsGLFCkQiEZx55pkAgOnTp2P69OlYtmwZzjnnHIRCZoD54osvRldXF66++mosX74cjz76KM4++2zXKJAXX/rSl9DQ0ICLL74YDz/8MJ5++ml8+tOfxqZNmwqzEQghBYdihhAyqPz0pz/FD3/4Qzz//PO48sorcfHFF+O2225Dd3c3Tj31VMuyIoV01llnWdJG4n41xQQA5557Ln75y19i/fr1uPTSS/HNb34TV1xxBb7xjW/4Xr+mpiasWrUKxx57LD7/+c/j05/+NCoqKvDDH/5woB+ZEFJkNF23dZIihBBCCBlGMDJDCCGEkGENxQwhhBBChjUUM4QQQggZ1lDMEEIIIWRYQzFDCCGEkGENxQwhhBBChjUjYpxBKpXC3r17UVNT49q+nBBCCCGlh67r6OzsRHNzMwIB7/jLiBAze/fuxeTJk4d6NQghhBAyAHbt2oVJkyZ5Pj4ixExNTQ0AY2PU1tYO8doQQgghxA8dHR2YPHmyPI97MSLEjEgt1dbWUswQQgghw4xsFhEagAkhhBAyrKGYIYQQQsiwhmKGEEIIIcMaihlCCCGEDGsoZgghhBAyrKGYIYQQQsiwhmKGEEIIIcMaihlCCCGEDGsoZgghhBAyrKGYIYQQQsiwhmKGEEIIIcMaihlCCCGEDGsoZgghhJQMuq7jty/vwMtb24Z6VcgwgmKGkGFGMqVjyR/fwC9e3Oa4/2v//SZ+sur9QV8nXdeh6/qgvNcf1+zCF37/OmL9yUF5P5VifcbB2naF5M9v7MGSP75R8O/hrd3t+PafNuDmP75Z0NclJolkCt947C3812u7hnpVCgbFDCHDjLU7DuPx1/fgO09uRF/CPJG8tv0Q/vjabvz7M5sH/eS4+Fdr8JEfvIh4f6ro7/UfK97DU2/tw5pth/N+rbauGM699znc8T9vAwB2tvWgK9bvuuyv/rYNJ921HOt3t+f9viqplI6/+/FL+MRPVyOVGh6iRtd1fOfJjXj89T1Y9e6Bgr72m7uPAAD2HOnNKpQef3035n33Gby+8zCeWLcbc7+zHG/uOuJYLpnS8YmfrMY1v3jFso0TyZTr/fnS3pPA3iO9BXs9lS2tnXhpy0G8f6BrwK/x4nsH8eiaXfjuU+8MSyHtBsUMIcOM/qQpGNQD9yvbDgEA+hIpdHqckP3yty0H8bctB30t29mXwKrNB/DOvg6829KZ1/tmI5FMYV+7cZJo647l/XrPvLMfWw9249E1O7GltRPn3vccPvvwGtdln3xrH9p7E1j5bmve76vS2hnDG7uO4NVth7D1YHdBX1vwxq4j+OuGloK93vsHunGwKw4A2Hmop2CvCwAb9phicd+RvozLLvnjmzjYFcPlP34JX/7Dm2jrjuMHK95zLLevvRevbj+EF947iJfeN9NXz2zcL+9v7cx/fxJ88mercd59q3CoO16w1wSMv/fz738eVz/0Cs67bxU2tXQM6HXWp7dxe28Cuw8XR3QNNhQzhAwhL7x3AN947C3PaIAbHX3mskLAGLfNg/SBPA7MB7ti+NRDr+BTD73iK9KyR7kCfWeAB1e/tLT3QVxAi5NpPryy1RSADz63Ff0pHe/sc/8M29JCY2seV8RuHO4xP8cbLlGFfNF1HZ/79Rpc/7u1lu8qH9R9bUdbocWMuf2znWiDAc1x3/i6Csd97b0Jefs/1+yUt/+gpFl2HS7M50imdLy7vxO9iSQ27i3s34N9/3hV+fvPBVUwqreHMxQzhAwh1/ziVTy6Zhd+ZfO/ZKKzzzwwi5NKvD+FtTvMtEs+YkaN9sST2cXM7kPmCaeQkZlEMoUjPVbBop7c2rryv5JWxeCf39gDwBCLavoOAI70xOVVdqGjJ4eVq/d1O/NPndnZ294nhV9Le4HEzFZzuxUyMtOXSGLzfnMf2nMk82tPcBEuTnljpH0Ey95uwaHuOPYe6cWqzWaKbGeBRFl7bwIic7PtoLvwPdAZG1B6x76tNw3w7+1tRWRt2Ju/mNnR1o2NeztyuigrNBQzhJQAh5WDbTbUyMzaHYcR709h/Z529CVM4XEwjxO9eoDsdxEzfYkk/rphnzxwqVf79rD3+we6BnyC/odfrcFpd69Aa4eZalDfK98Q/q5DPZbX61c8E/btpwqYbQe6C+ozONSjipkjBXtdwSYl0nQky36WTOlY9nZLxv1H13VLZKaQYmbz/k7L97AnS2SmzSU653ZCPaJEZhJJHb9ZvR2/+ts2qF9joSIz6n75/gGn8P3bloM4Zekz+Op/v5Xza+9Kb+t5U+sBWL/bXNZP3e/VSNhAeeiFbfjID17Ag89tyfu1BgrFDCFDhHrQbayJ+n6eGpnpSxhCRj25APlFZixixsUU+euXtuP6372On6WrpnYrJ4FN+8zntvckcN59q/B3P34JrZ2ZvQ92euNJvPT+QcT6U9i837y6Vd8r3zSTiMpEQs7DoH37bVVOSp2xfhzIUSzuPtyDe55+x1WAqZGZd/d3oide2Ktb9fu0i+blG/fjgRXvSXH2zDv78Y+/XYu7/nejXOal9w/iJ6vel8vsPNSD/R3m5999uAdJH+bZtTsO456n33FEvVTsJ9ZMaaaeeD96XV6r203M2D73j1e+j1/+bTsAYG5aGOw65P1ej63djV/9zV/0VE0bukXxnlhnRAD/e+1uLHs7Nx+TEI4XHDcegBEJzdW4/HY6EhNKp+g27GnPW5wLcTSpviqv18kHihlChohdyhVtOOgWHAdi/UnHgaazz3qwfntvO95OnwTE64gwtp+TjJ23lRx6f9L5/A3pEPWu9IlGvcpr645LIfBL5eC/ucUQJNsOduPvH3wJK97Zn3EdNrV0SG+MavRVr9TF/QMtDX4l3cfk8jkTHY85xYw1XbDtQDf6Ekl84ZHX8R/POA2ndm59YgN+umor/uhSCnuo2zzRJlN6XtVS9/zlHZz5vWex8N7n8H/pE6UqZuxpu1sefwv3Ld8s0w5bWrssP3Vdx81/fBPfe3qT9Gcs32h8d3On1iMc1JBI6tKUnYnvPf0OfrpqK55Jf/e7D/fg6p+/jB+tNK/mRcpjUn2lsUwGj8/BTuOzVIQDuPUjH8T5xxgnePfIjLHsFXMnYeHRjYgnU0imdFxywgRce8Y0ANa/R5X9HX34yn+/iTv/d6PFe+OFKlhFmmnXoR5c/uO/4S/r9+F5JbX1rT9tcIjXn6x6H59+6BXH59B1XYq7D81qRCQYQHc8mbMPSgjGhR8ch2BAQ1t3HC0dfdB13SKMvI4dqZSOL/7nOtzzl3fkfeIiY+LoypzWpZBQzBAyRKgHT7er1UPdcZy6dAW+8PvXLferkRmxnDiATm+oBgDsONSDs76/Elf97GV5gOpLJPG3LQczXhl39iUsV5P9KSPN1J9MYe2OQ+hPpuSJvSN9YLdfPW9q6UBHX8IiZnYcMl5z5aZWWVouaO3os/gkAFMwic8nsAinrji++l9v4pTvPjMgE+N76RP2glmNmJHebgJ71Geb7Qp768Fu/O7lHXhq/T782zObM14d7zrUgxfeM05gh3tcIjO2+170WUVmR9d1PPTiNuw50ottB7vxL3/dBF3X8W6Le5qpvSchP6c4GQlRIiJp+9r7sK/duP1+Or326BpDkF1+8kRMTl+J+/GbbDtoLLPrUC/2tffiqp+/jJfeb8N/rHhPnrhFOfPZH2gAkDnNJKJjDaOi+McPzcTVp00GAHTHnPu38MyMrgzj7suPR31VGONqorjjo8dhclo4eaWZ/u/tFpmO8mOIVyNtuw/3oi+RxO9f3YnXdx7Bkj++gdbOGCrDQYyriRqVbLbU4vee3oQXtxzET56z9os63JOQ22na2GocNW4UAHga1r0QgnHe1Hp8IP0ab+5qxw9WbMHR334aG/a048Hn3scx3/4r1u5wGoy3HOjC/765Fz99fivW7jgEXdfl9zSxnmKGkCHlpfcP4j9f3Zl9wQKy0yJmnAfJTfs60N6bwAvvWU9uHb3GAa2mIgTAOEEJT8AHxtUAAFa9ewB7jhjlqC+nU1D//sx7+NRDr+D0e1bg8dd3u67TO/usokJEZh55ZSf+/sHV+OnzW+WJXVyligPZ1LFV6fXuxJNv7rNEkETFizAUi2hKfzKFT/x0NS75wYuWFJIaHTpkOzkI2rpi+K+1u9HR14/LH3wJiWQKiWQKP131Pp7ZuD9r6FxEdsbVVmDxmdMws7EaZx1lnES90kxC9Gw72I2n1u9TXstYx33tvXjwufctqY7/Wrtbngz74u6iFQBOmFQHAPiZso1zoTeRlFfTAc0QH6vfb7P4NlThJAQmAOxNl0C3pIXLwa44EsmUxcOzo60ba3ccxpbWLlSGg/joic2Ykv7Os/lmeuL90oezr70X333yHZnWifen8Owmo9w9kd4/hCjf196L/3x1J15yEXgHFTEDANUR4+8hU5ppdFUYE+oq8ezN52D5kgVoGBXFlDHGZ2jp6HON8v1F+Z79pGNUD5SuG/u+iAKKv/PTZ4zB7InG9+1lKH/+PWv/HnHxM64miopwEB+cYPytZzLd67qO367ebjH1v5e+cDi6qQanTBsDwIi2PfzSNiSSOla804q/vt2CeDKF367e4XhNVaz9YMUWHOlJoDu9XzMyQ8gQ89X/egu3PL6+4GW3mVBPzK6RmfRBsbOv3xJy7owZB2ZxED7SE5fpgw+MN6601OX/kL6S3tLamV4+gSV/fBO/dKmgskc4hGdGmHj/+Nou9KQPXO29CfTGk/JEfs6sRgDAtrZuGdYXbE8fsPulmDF+rtp8ANvbehBPpixlp+uV9RCvn0xZ0xndijCI96fw8xe24sX3DuKepzfhc795DQv+9Tl89Icv4r/XmsLtqbf24brfvIb23oRMUzSMiuD/zZ+GFTefg5OnjAYAHOjqQyqloy+RRG88iW1txvqfd8w4AIa3RD3R72vvha7rOOv7K/H9v27Cb9IngWRKt3RZ7ckgZq6dPw1nHdWAWL8h8D7xk9U5RZyEeAwGNFx+8iQAwNK/vGNJF6hG2O1KNEVEREQUBjD636jm7e1t3TIqc/EJE1BTEZb74A6bmOlLJPGlR9fJCjF1X997pFdGB8T2fjotGBJp8dxUV4lIMICUDtzy+Hp86hev4Il1VgHuEDNRQ8y49VgS+2NdVQQAUF8dQV1lGAAwpjqCqkgQuu6MBB3silnKn/1kbQ/bfFFv723HW7bUoRoNVP1Yqlh6a3e7JeInIkdim3+wyRAzmSqaVm9tw7f//DY+9qO/oTvWj2RKl9/7zMZR+PDsJgDAE+t2Sz/V5tZObEkLnhXvtDoEnroPrdp8AH/ZYHx3DaMMkTVUUMwQAvOKVT2YDwRhXF39fht6lRNXT7zfEYq3pJlcrgjViESLsl7ipCXFTG9CXnnOGl/jeJ2nN7TgSE9cNgWb2WgcRO96ciOeszWAs1cjiTST8MeoPUU6+hKydLYmGsK4WqNMtj+ZkpEIUTorrtzFyUqE68XJETDNw7F+a3nuoXQqpLWzD4mkjmBAQyToPHQ9+eY+bG8zTww7D/Xgrd3t+Nf/2yRPEj9auQXLN+7HU2/tk+ZRcTIETCP2e/u7cPa/rMQHv/1XHHPbXxHvTyEc1HD2BwzBttVWpbL3SC9Wb22TwkGIkOc3H7DsUz0e6UQAGDMqgnsuPx6joiEc6Izh1e2HHB6bVErHe/sN06euG7eFQBTpx1HREK46dQoAawkuYPXM7FAiAnvTIlHdz/Z39GGdIjC3H+zBynQE5Yq5hlgS+6B9337yrX340xt78c+PvoFEMmV5fOehHiluvrDwKADAyndb0RPvl58lEgxAU2xkug7c/Mc3LX4iUcnUMMoQKCJSmTEykxYwKpqmmZ/DJsqWvb3fImBSfiIz3dY08GOv70Z/SkdTbQVmNFQjGgrgvGPGY3qjiPKZF1D2CK36/Yl1m5xe12Mm1AKwCn877ynm+Ude2YG9R3oR708hEgqgeXQlTp0+BmOqI5bP+NKWg/JCoTPWL5tn7mjrxuHuuMN39dALxkXRUKaYAIoZQqDruoyM5FPSDAA3/v51XP3zV3DVz1/Gzf/1hnL/Opxz70pLuDdbmsmvmGlp75MnZpEDFwQDGuL9KfxlfQta0xUo93/iJFx6YjMAWLqhAk5viEgzuaUR1O6hE+srZQOzlA55RSnSBdvbDL+FEEfxZAqtHX0yvQCYQmrj3g4petTtIK6aJ9RVYGz6BAaYAmTPkV4pHC4/eSJ+9Q+nIBzUsL8jhh1tPUildGxNnzjW7zkCAKgMB+UVvfpar2w75DBWXnhcE+ZMGS1D6ZFQQAqhPUf6LJ1ndRjr/2i6QdvYamN9e10iM0JIj6mKYPKYKjz9z2djcdqU2mIT1z9+bgsW/dvz+N5fN+E/X92FRf/2PL79Z2MUgyjZr6kI4eQpo3HmUWMBGCmncz9oRJQOd3tFZowUS5stpadGhja3dqKtO45IMIA56YjK1LHG97vzUA903YhCbWntslQZrX6/zeJH2by/C8mUjopwAAuPHofJYyrRl0jhpS1tMhIYDmpSCAcDGk6bPgYpHRYPh1dkpieedHiYREp0dJVTzABmFc4uW2Tm6Q37LL/7ETPi+xQm5r9tMf7GTp8xBo99/gw8s2QBJo+pwowG429VTTPZTb+rNpt/HyItJ8TMCZNGAzC2vVfPJTV1+7Pnt0pxNG1sFYIBDaFgABemK6PM9beKsR+tfB+feXgNFvzrc7jq5y87HhfHjEkUM4QMLYmkblbO+Cz3ffKtvfjWn9Y7+rCoId/Xthsh+q0HuvDsplakdDP/ruu65QAfczEWquFqNb0ijLeTRIg/fVIKBjRMHVttuaJdeLQRSXivtVMe/MfVRjG72biqy1SCDBhppt540rXUuy+RkstPHF0J0Yw1petIpg/6k+uNg2ZfIoXWzpglMrPy3VYkUzpGpU9Cm1o68eirO/Gph14BYER7AMPbEu9P4cG0IXLa2GqLmDk77XNp703IiM6xE2qx8OhxODF9wH912yG0dPRJ0SiuZhtqzNcBnCXyV506BRvuvBAb7rwQP7z6ZNRUhPH81xYa991xIS47yRCFq99vw8tKI7n9HTG0dvZhxTvGyejq04xIib1yRdd1MzKTFjyTx1ThjJmGENlv2+73LtsMwDgxiSog4fXqSouZUdEQNE3D7z57GjbceSE23nURvnjuUXIbCXa0qZ6ZXil2Bc+924pYfwp1lWEENMho27HNtYiGjHSCTDO1dePFLQfx1f9+C7c+sV5G0wBDELiJ4aljqhEIaDiq0TipH+qJy/0jHAzg9o8eh3M/OA7P3rxAio1Yfwob9rTj1ifWy6iDiMyMUkRpt207m5EZ6/ctmDwmXT2l/E0e7o47xL7YBrsP92DJH96QZc4qatqwRlmn02aMRX11RIoRESHddahHRirtYuahF7fJLsIikisMy3WVYWkCFinalZtasfhXr+LaX76Kv27YZxGsB7vi+HG6D4wQUgDwkeMnGNumKoyKsCkJhJhcu+OwvOjY1NIpP58waQsmDaFfBqCYIWWMrutoTZccZkJN8WRqxPa9pzfhI//xAjr7ErjnL5vwu5d34jWl6679+a2dMXTF+qVnBYDsOHqgK2aJxqiemcPdhvnykHIFlCkyI66C6yrDiIQCGJP2BURDAZwx0zjgbNjTjv6UDk0zrmTFSVsVKe09CXllLk4QyVTKcoC3I8yHzaMrEUirKF03vQWRUEBesW0/2C0NnvH+lPwc86YZfT52H+7FbX9+Gz3xJI6fWIfvX3GC3Ka3/88GrNjUimgogJvO+wDGVpui4/hJdfKKe21aQIroyWkzDIPjy9vaLEJNrLeaYgKAxlHWjrKnTKvHqGjIcqIMBjSMioZkqB5wmjVb2vvw+Ot70J/SMWfKaCmq7JGZ3kRSClkhZgCgKX0i2d/eh9Xvt+FD/7LSMRNquq0CS2zP2gpjW2iasZ4V4SDq0/uE1QBsfq8HumIOwfFMugT75CmjLSmEkyaPlrfFPtjR14+X0ybX7Qe7caDL3F+Xvb3fdeSBMIyH0ynD/qQuLw5CQQ0Ljx6HXy4+BVPHViOaPsnG+lO44ZHX8ftXdmJ1+v0a0vtyNBSQ0UG7KBCeGa/IjPh7UC9mlr+zH8mUjmMm1MrvX0Rm/rBmFx5ftwe/eMHpOxPb+OSpo/Hrz56KUdEQQgFNmsvV96yOBJHSgZ1pM7ZIkdVWhHDS5NE40pPAp3/xCg52xfBuWqir3/uc9Hch/Fv3LnsXz717AKs2H8B3nnxHClZhLhfeHZHiAoCzjmrAdy+bjZ98eq4URwDw8bmTcNslx+JTp03BZ8+aLu8XvsJ5U8dYxBrTTIQUicdf34NT716Bn6zamnE5VUhkGl74p3V7sHFfB156v016DPYr3Wl740kpLEQjts37O/GYUjm0qaUTLe19Do+BWIe/btiH0+5egX/8zWvWyEz6ffoSSVkRJE4kAnGgFgfmWeNr5DLiIDamKoJwMOAqZkQKZnxtFLVpb0EiaUaQ1IiP4L20qXh8bRSaJtJMuhSQAc1MRexo65Fpq3gyJU/i42sq5FVgPJnCMRNq8T83nikrLY70JvC/bxoRrR9cNQenTh9jicxMb6iW4kWYPycIMTPdiHC8svWQ/HzicwGwiCLAGamZM6Xe+aEVmken1zv9Wc5Lp3NaO/vw2nYjUnPJCc2oihiRDLsBWIjfSCgglwGA8Wn/0YGuGP7nzT3YeagHf11vNlgLBjRMazC//46+hPTMCO+IihAzPfEkYv1JdMf65XcfDGjQdefcH5G2OmlyPaaNVU6g6RQTAFRGjBJjAHjuXVOoqwMi27rjlnSiYFr6pCzETCKZUtJM1lNTNCTETNIhuoQgFeINsPpm+hJJeeFQ5yFmxAWAejEiTMkfnt0k933hiRITq1VBuKmlA69uOySjUvVVEZw8pR5P//PZePyGM2RERqBpGmako1Ki4kwI0saaKH79mVMxo7Eah7rj+Omq93GgM4ZIKCCroABz/1y36zB0XbccV/Yc6ZWve83pUy3vrbYi0DQNnz59Kk6fMVZWQwLAUeNr8JmzpmPp3x2Pb19yrLzAES0NxlSHcaIibJlmIqRI3PxfbwIAvv/XTRmXi1nGAHhHZkSIfvX7bTLcrIoBcUUWCmg4IX3A+e3qHTjYFUdjTRTHp+97fvMBR9v6WCKF5zcfwPW/ex3xZAor3z1g8S+IyIw42GmaeSIViBOWECpHN9VgUjp8LoSDeEz8VD1CInIxvaEa4YBxaEimzAPkKdPGyIO6OGmI5mrjaiqUNJN5BatpGqamD+Lb27pNz0y/KWai4QCObjIPoledOhmapqE+feLRdeNKOxjQcE46bTZWiWLMbBzlKAkV22bu1HoEAxr2HOl1lLgb28EqXqoiZhRmdFUY08Zm7mjabHvfhWkxk0jqeD39Hc8aPwqVLmLmD2t24pcvbgdgnEw1RS02jIoioBnb//UdxuuoXYdHV4ZRFTFFy5bWLrlvuImZmoqQ/H7aexIyUlJfFZZpi9fTUUZ7A8c5U0bLKAoAnGwTeEIwCz+Grpu37bOT1NcRt0Pp9xOl9YDZnVYg0lqxREp27BWo0TXx3XUpvWbE320woFkiCSoiKib+5hLJlPS6XDS7SUYdRcRR/K2oJv6L/v0FfOKnq6WgVtOGwt9iZ4Y0AVsjM6MqwqirDOOyk4yGjqI67qTJoy0VQ0JYvrmrHYe64/K9xX6bTOkIBTRcemKz5bPPaLRG9QRqZMbuvxPbWYjJ0VURi7CdOHrouv8CFDOkTFGbWzWMimRYEhazojDS7TrUg4/96G948q298vXEci8oKYUDXTE89MJWXPmz1fLAVl8dwcz0FZfoRXLu0eOkCfO5za1y/IDwRvT1J/HzF6wRJPVAaYqZdMVKJIRoKGg5QIlKDXEVfdLk0Y6TvKg4Egcmw6dgbCtxQJ3ROEqG6xPJlDRFnjipDvd9/ER8/++Pl1EBcfXeWBtVDvimBymgafKKbV97n8UzI0o+o6EAPthUK29/LH0ADwUDlrTA1LFV8qQ2Nr3+ItWjtlEPBzU0VJumUBFid+s6bE8zAabQmzN5tEVguDGhzrp950wZLYWWuMqf0ThKCg+xD7V29OHrj62XjQXrq637aDCgyfUQ6QVVONdVhi0l11v2d8kT2SgXMRMIaLIU+XBPQqYfpo6tlp9hbboM+9h0lYzgxMmj5T7VMCriuAKf4iL4WtKRxG9efIzl/nlTx8jb4jVlmimly8idV2Smrz8Jm86x/H1XR439ozvWL/drIWbqKsOe36eI9B1KR2aP9CQQT6agaYZYFu8puuSKv5XWzphrW4WAZqb7MiFNwOlIj0iPjUp/jgXpdgdC+J82fYzl+bPG16AqEkRXrF9Gv8bVRDE/fVwBjIhJRTiIM44y71M9MypCwAQ0ZxpT7I/iQm50VdgqZhiZIaTwqBOkJ2aZF2JNMxknoBv/cx3e3HUEN/5+HQBr1121CdmBzhh++eI2vLz1EJ7eYKQBxlRF5JWPEFWnzRgjxcyzm1rlXKAPpQ9WfYmkY36MmvcXJ4cO29W3GjYfnY7MLFk0Cw9cNQcfnzcJNekrPIFICdRXRWR6wZwGbRxQZzRUy6vzZEq3lIRefvIkfPKUKY4D9biaqBmZSekyMhPQIK8k4/0pi2dGRMSioaCMuFx16hTL+qo+EmEUBczIjKjKUA+kE+oqEVDOeOLq1q1HiKuYSd+XLcUk1kOkFCPBAD4wrkamiACj1f6E2golzWR8fyKiZX5O54lPfR0AlvlWtTYx815rp5Jmcj+JisjdkZ647PNy1LhRMrok9j81dTCzsRp1lWHMnzkWAQ348OwJDkEwdYz7VT4AnDBxNE6fYZ6Apzc4IzNiX0so+0fIFh2SnplEylH5p+4voqLpoRe24phv/xXPbNyfsSxbMCYtfkWKSERZayvCCAY0S2Rmb3uvxbDv5imrr4pY9kEvjm4y9mkRxZOCNP05jp9YZ/kbEGlTQTCgyYivuHCaPKYKcyab+65I8y6YNS69bmGHeBacNGU0KsIBzJ1a7+gZYzfH11dFMHfqGNRWhHD0+BqLr2wooJghZckqZf5Jl639vx314CgMgG96+Afs7DvSJ4WGaCs+pjriuKo5bcZYnDCpDh8YNwp9CcP8OioakiHzvkTKtT+G4FB3HH2JpOOEJU5Qxu30fdURXHpis4xiqNEZIWaCAU0Kgk0tnXjwuffxl7QnY0ZjtRKZ0c0qCiXnX1dpFzMVNs8M5PuIq+x4MiWvvGOKZyYSCuD0GWPx6jfPw7cvOdbyumo6STQEBID5M8di6tgqfHzuZMdntKc2LjtporyyB2CJZrmJmUtPnICJoytx8QkTHI/ZCQTMEuKjm2oQCQUwvtZ8zWljjYodkWbqS6TSJeLWqjG3q3i7mFGHO9ZVhmXKDjB8DJnSTIApfA/3JPBKuvLq1OljHOlK1eArBN1xzXVY+61FuO1S6/cDAFPGel+RN9RE8G+fPAnHTKjFl87/gIwCGaXX4nbaM5PSlTSTPTKTTjMpET3A8IKo4kqcUFe+ewD9KR2f+81rsi+Kl18GMEVzdzyJvkRS+tXE/eq+ba/4E2XpKm7RMTfmz2hAQDPE7Z4jvfIYIERZIKDJqqFQQMPJU0c7XkOIGdEPZsqYKkvERKScPnJ8E06cVIdP2/wzKuNqKvDi18/Fbz97muMxu5gZXWVcKK366kI88YUzfH3eYkIxQ8oSVcx09BkN6z7z8BrZVlyg9pgBjGhIhyJ+RO6+w2PA3IY97fKKf6MiZmYoUYRJ9ZWYOLoSmqbhynQzM8Dwc1TJk1xSRmJUX0EkFEBl+gppf0efWbFSafo6BF6VGmrUYpxyQBIHp28+sd7iK5rRMAohGfpPKSWh7mJGCCP16lX0+dA0zbzyTtoiM0qayVi3CimiBOpVqWpOnFRfhVVfXYjrPjQj/bv5Ge2ptbqqsCw/rakIyTbwACxGYsE186fhb984V6YKs9GcPinPnmikZ1QRIl5DNff2JpKOE6I9UmO8jvck9XBQs0Zm9nfJ0uxskZmW9l68ufsIACNtYRfexzXXoTq9vupJsb464kj/AMAUj8hMdSSIqkgIE+oq8fQ/n40vnT9LVtHMVFKZQrhYDcDW/aAibBqAxcXHY58/A9+5bLZlObfogOjgmykyU1sRku95qDsue6mIvynxsQ0xY/2udh3qdUT93Kq33KirCkvB+PzmA+Z3qHwOEdE9eWq9xSclEIZgkcKdXF+JmY2j5GuIyMzoqgj+fONZuPmCozOuk1cn38ZRdjFjdlN2W6/BZujXgJACYx+u19mXwPW/W4uN+zrw7KZWbP/exQCALzzyOt7e244ltj/ulUrlhTjhe03LVVunC6FRX220eQ8GjBPOqUqe++/mTMT3n96EeDKF02aMkQeNvkRSHhBnja+RB8MxVUar9a0Hu7Gvvc8RmRmtRGbU2yrqiV490YrPpraaF54IcWDvjvXLbqDqybVWOTE0jooiENDkAV+3eGbMyq5EMiUFj3htAJaoiR1Lmmmct7hQP+MEW6QBAP7f/Kn43zf34rTpY9IH3sPpz+stGPxy/KQ6rN7aJsvg1W0s0o0VIfPk0BNPyq6vY6sjaOuO43NnT4edplrn5xAkFX8JYFSujEt/P14mV3EyX/nuASSSRkfaKWOq0FRXgfbeBA51xzGjsRpHN9Xg2OZavL7ziPxMmVDFt9jnAeeVPGD4kP71ihNwXLNZkSP2tX4lchdyeGackRm3/aba5bM/lB7b4fX3ASBtOI+gtTOGQ0qXWyEA1bYD9saSOw/1DGg6vWDBrEas3XEYq949IEvy1c/x0RObkUjqOGWae9pTiGjB5DFVCAQ0nHvMOPzPm3tl64N8Ub/PcFCTgrdUoJghZYfaBA8wQvsbbZNle+L9MscsSmgFT71ldv0UV0odWVJVKmOqDB/F5PpKbG/rwelKnntMdQT/cNY0PLZ2Ny45vhnB9IG8L5FCIp02OHp8DZane3yMqY5gdFUYWw92o6W9zzFkst5PZEZNMymCxH6l9cjnTsPMRiMqE0xfLavVN1HlhGzx4dSapbGAtZopoJlppkS/joBmpkaE+ItmmOdihvmRMVJSVxlGdSSI7njSUWEEGOmSFTcvwNhRUTygdOq1b4OB8JULjsZlJ03EMemIjypmRNQjENBQGQ6iNz3rSaSZHrh6DhpGRV0/27gMYqY/ZTYmFIhxEF5pJnEyF1HL02aMgaZpiIaC+IczrWLqoWtPwcGumCNq48bY9GyjnngSJ0yqk5V6bmJG0zR8fN5ky31mabYu/wbCjmomp2fGLXqQybdhT43aGVNtiJm27rici2YXMyndTBHOnliLDXs6sMsmZqKhAL5rixhlYsGsRty/fDP+tuUgzj/W6Marpqk0TZPjI9yY3jBK7luAWV12z+XH48vnz5Il8Pmifp91lZGs5vjBhmkmUna4zTmys1mZWRKzGQqXbTSrXrri/UildCkiVLz+loW57suLZuHSE5sd3otbPnwMXvvWIkwZW4WKkOknEecmtUx5THVEnhyNNJO1l4gaOq/3jMyYV87japyRGcAIs58xc6y8MhQnE7XSSw3917qYiq3VTKYB2PREpCzRBClmMkZmounPUCl9J25omiYP2l6G1KljqzEqGpLbMxIMyHRdPkRCARzbXCsP7k115nZV041i/dt7EzJ1d1TjKMwaX+NIrwFOz4xKMqU7ogHiu/JOM1nvP9VWGaNSVxn2nWbTNE0u+6H07CrAXcy4Icy+sX7zb8AZmTGrmTJHZsx9pLYihEuUv71s6yNSjsb8IePvTGwz8bee0s2ybFFptPNQj8W/9ObtFzgEWyaOn2g0feyM9cuUmFd0zY1gQMOxzWZ0RnjbqiKhggkZwCr87ftSKUAxQ8oO4YHRNO8rtU1KpCZTozxdN4YD2iMzY6sjnikKEU342EkT8cBVc1xD3wL71WXAFoGor45IsdDaGVOqmdzSTF5zZ8xIRaOLZwYw8u7qlZY4ufalIzPhoGZ5vFa5cmxMCySvPjNunhnArBBTIz52RJpGrc7w4ruXzcY3PvxBS1mqG8KwO3ZUca4uVcGoRjaE9+mdlg6kdMNTkukEq6aZxtmWS6Z06S+x4xWZUbu+BgMazj6q0XW5gfCdy2bj6xd9EJ84xTyJ+416CbHbq4wgcFYzmQbqTJEZ9W9tytgq/PDqk/Ff18/HTed9AFeekllgCOHc1h2XBmBxYaIKdWH4nz/DSMHtPtxrEZb2HjnZCAQ02cROzAPLdMxwQ5iAI8FARhGcD+q+6nXhNJQUVcwsXboUZ5xxBqqqqjB69GjXZXbu3IlLL70U1dXVaGhowE033YR43Nq4bP369ViwYAEqKysxceJE3HXXXVlb1JORi1nyG3CElsWJVZ2h1OYywmD2xFp5UOrsS0jPjLganDSmyvNgncsfuv2AXB0JyUZ3ADCmKiwPIq2dMUfL+tEupdl2ZjaOQlNtBeZMsTbcsosZFXGCEWkme3WJW7m36Suw9pmJKGmmRMoZmYlkiMws+EAjHv3H0/Gdj2UP28+ZUo/rF8x0jXKonDRlNKoiQUfPjkIxs3EUxtdGMWfKaMt2EiZgMWtnRuOojGJK9SjZfQ/JlI5kOspl335eAv7Dsyfg4X84Bf/+yZPw2OfPcO0PM1BOmjwanz9nJppqTRO338iM+Ju0RAEd1UzG710x86IiGnbuN5b2+ul04ynTxmDJolmyN5EXY9J/S4e6Y7I020wzGcuklIiYEIddsX5Ls81s+58b9tRormXOx6UjM+rA10JTVxmW31WmyrChoqiemXg8jo9//OOYP38+fvGLXzgeTyaTuPjii9HY2IgXX3wRbW1tuPbaa6HrOh544AEAQEdHBxYtWoSFCxdizZo12Lx5MxYvXozq6mrcfPPNxVx9MkwRkZmKcNBxlVpXKcqRlciMS9ffK0+ZgnuXvYsjPQl09fXLaqbLTpqITfs7cc3phqEU+xxPtZhWs2GULmuyEqE6GkJtRRi1FSF09PUbkZn0lVZrR5/8PKZnxlmabacyEsRzXz3HccWoirHjmq0mwqAtzWSvLnH3zBi/28cZhBUDcChpvk5Hn1UguhEIaDh9RuZIS65MqKvE2m8tsgzVKySVkSBWfXWho/JHiBkxnNCrC6tgdFUEH587SY54+IsyzkD1zEwdUyVbzAPezdqMDsrjcv9AORAMaBhXE8W+9j7/aaa0cOlV0r32/U3sI+1KL6YKl4ieGtGYlKW/lB3Za0apZhJ/U0Koq9GwynAQFeFAutVCIr0cBhTty1fMnH/MeJw8ZTQ+emJzzu/tF03T0Dgqir3tfSWZZiqqmLnzzjsBAA8//LDr48uWLcPGjRuxa9cuNDcbX8J9992HxYsXY+nSpaitrcUjjzyCvr4+PPzww4hGo5g9ezY2b96M+++/H0uWLCk5ExIZekT/kopQ0HFgr6sMQdd1S2TGbbjkR09qxk9WvY8jPQl0xvpleufopho5APFlpcxbiA/A2c01G9FQEImk8dyqdM5/Un0VNu7rwBglzXRASTOJ3iAiMqOWcLvhFpJvyBCZCdmulu1X/1bPjEgzmY32hIUgYOszE06aryMEXCYxUywy+W8Kgdv2Fu8pjLrqvCMv/vXjJwIAHlfmewFWz8zUsVYx47fHSbGY2TgK+9r7fH0+wBS7aprJHl0QqUhRPahpTsEDWMWMvUQ/G2PSnpm2rriMzIhop302EwAENS0txMyeSfYIpl+abb2Rcv0O66sjePyGMwf03rnQWGOImUyVYUPFkHpmVq9ejdmzZ0shAwAXXnghYrEY1q5dK5dZsGABotGoZZm9e/di+/btrq8bi8XQ0dFh+U9GDmZkxmnwHJ0uv1S77Yr+LqKB3eIzpqG2Iix9KZ1KZEY9iQvPTCigWbqmjsnxD12NEIgrMpFWOK65VoqZ/R190jgqKhZmNIxCdSSI2YoB1S8TR1dibHUEU8ZUYbrtxCOiOL0DSDNZPTPmayWSZsWWSqZqpnJC9OIQJ+SmOv/eBnuUQ/XMqH1eqiPBoqUZ/PL9K07AT6+Zm9FgrGI3m9v9WYCZUhLugopQ0HV/VyMaubbXV8dQ2JvmuUVmtIApuoSYGaCWkYNRBbl6ZgYLsR96+fOGkiHdYi0tLRg/frzlvvr6ekQiEbS0tMhlpk2bZllGPKelpQXTpzv7M9xzzz0yKkRGHn1Km3x7ZUdVJCg79do5+wMN+Ok1c6UYEfn3rj6zkZ7V+Gr8YTfVVcirwMpwMOerftUAW50+4d1+6XG4ceFRGFdbIcVWt1ImLULodVVhvPj1cwcUaagIB/HszecgFNQcrddFNYk8wYScaaaAZggXcVK2zK8RHYA1TekzY+2NYn7+kVGHYP+O7KbeTLiJmWRaGKrTs4c6KgMYIjmXqEgoiz8LcO4jbn4ZwCpmcp3iLITLwa6Y9MjVy6Z5Zi8cQUDTpFCP5xmZsW+vXKqZBpNLTmjGu/s7LVVrpULOW/6OO+6ApmkZ/7/22mu+X89NXeu6brnfvoyuVEq4ccstt6C9vV3+37Vrl+/1IcMfS2TGdnB3a3olqAgHjWnF6QOUODF0xUwDsBqZEdGRmY2j5Ak9F7+M+b7mn6G4IgsGNOmVGRUNWTrIjquxduisr464pjX8UFcVdr0KFAfpHlnNZD1UhIMB3PLhY3DTuUfJ6gmx3VI6FM+M0mfGVs0kGClipipsFzM5RGZs5tX+VEqmPOqrIvIk7lWWXcpIA7AQMy7pI3vFm5tfBrB5ZnKc4iwiM9vbeqQYN9NMzshMQFMjM0l530Cwj+AoBVHqxmVzJuKFr53rSEuXAjlvsRtvvBFXXnllxmXskRQvmpqa8Morr1juO3z4MBKJhIy+NDU1ySiNoLXV6NBqj+oIotGoJS1FRhaiz0w0HLSID8BIf7idUAHIni8CYbI10kzWKiIAWHh0I+65/HjMnzFWTsGudxkYmA1ViIyKuh+kx9VEsb3NmmIqJuIKUwhDe3UJADlKQODWZ0b1NhhixhmZyVTNVE5U2SMzGcYV2KmvimB8bVTOZ1I9M6GAhomjK/Hu/k7PsuxSJmyPArqMTLBHYrwiM011xlDPxppozj2E7Bcio6IhuW8KkZK0iBmXyIzLuvt972gogFh/CgENGf1vxJ2c9/yGhgY0NGRvce2H+fPnY+nSpdi3bx8mTDCaGy1btgzRaBRz586Vy9x6662Ix+OIRCJymebmZt+iiYwsYkofCvvB3TgJuD/PngYQV7udappJOUCGggFclZ61pGlGHvncD7oL7EyoYsYrVz6utkKKmcmDIWZsV8v2NJMb1j4z4j6lNDupW5qLCTL1mSknKpX5NZpmHaKZjUBAw5NfPBtrdxzC9b97HUnd9MwEAxom1QsxMxwjM/Y0k3Nfs0divCIzo6IhLF+yABWhQM4esvqqiBwvAVh9IUKoJ2xppoDNMzNQv5KmaWgeXYltB7tRHQ2xsGUAFPWSaOfOnXjjjTewc+dOJJNJvPHGG3jjjTfQ1WU47y+44AIce+yxuOaaa7Bu3TqsWLECX/nKV3DdddehttYoFb366qsRjUaxePFibNiwAU888QTuvvtuVjIRT0RkpiIUcFQzqVED+0HTnqoRod627pi88vJqiT51bDVe/9YiLFk0K+f1dTMA21H9FYMiZhymzOyHCrXPTNKlA3AypcvtqOJ1lV1uqJGZsdXRnK/iG2uimJhOnSSTSmQmqEmza6l6LTIhhLPYN9z2NcMUbP6eaZ+ZOLoya08ZNwIBDRcc1yR/V9seuEdmzL+TWPrvJJjHOUlUKOZalk0MinoUue222zBnzhzcfvvt6Orqwpw5czBnzhzpqQkGg3jqqadQUVGBM888E5/4xCdw2WWX4d5775WvUVdXh+XLl2P37t2YN28ebrjhBixZsgRLliwp5qqTYYzaIdSZZjInOtsfs0cIhBDakx7EGNBMg64bdhOtX9SrTM/IjOKvmJyjsXEgiIN0Xw5ixrXPTECTpbeAtTGaYKR4ZtTUQS7mXxVpRFXSTMFAAMdOMC7+CtkIb7CwpzDdPDPGDClzOa/ITL58eLYpZtQLFzfPTDCgye8jnswvMgMY/Y8AipmBUtSt9vDDD3v2mBFMmTIFTz75ZMZljj/+eDz//PMFXDNSzogTcNQlMpNUmo3VVIQsPWbsTdTEQUW0GK+pCA9YsGRCjQjZfRUC1V8xKJ4Z2WLevWmeG9Izk4LsM6OOMwDM0lqVyAB9BsMNNY2Zi19GRZwsVc9MMD2IcOrYapyktAgYLtj3La9xANFQ0KxULFI0Tx2FsUXp3SNWSa3G02SfGTO1nY+YEY3zSrUsu9QZGUcRMqKIZegAnNJ1MzJjEzr2NJN4rojMFGIooRvRUkwzBQeeZnIMmsxQrhodgLdhuGKvSBsIUszYPDOhYADzZ44tejPAYmBPt3nta2pkplg+q3AwIEu6Z080u2KbfWbS/WTSu6w9MpPrXCYVEXEtxe66wwFKQFJ2yA7A4YBrNZOIzNjFicMzkxYWor+LV5v4fPFlAK4xJz0Xa5Ccijgoi6i6PzGD9HOss5kCAaPqw20w4kipZALsYmZg36H4XuyemeGMPTLn9XlU0V9Mn9UTN5yJn7+wFYvPmCbvk2ImaQpIwDrxW71/IHzk+Al4t6UTlxRxJEE5QzFDyg51NpO9z0wyBVnNVBO1R2ZsaSbbc4smZkJqabb7n+TRTTWoCAdw0uTRg9Lh1d78y0+aSdNMAaTOZgKMg76bmBkplUyAtZppfJ5ppv6UWRk21B1/88UuXrwaz6n7SrE8M4BhtL71I8dY7hPBQ7HNxb4etBuA8/guqqMhfOuSYwf8/JEOxQwpO/ospdm2yEzKTIHYIzP23g528aJ2Wi0kbk3z7DTWRPHSN85DtUcfmkJjP8HkHpkxm+aJ5/clRm7DPMAamWkcYGRGTTMJX1I+FTSlgF0oe3moLGmmQa6AU0UkoIj0AhqASX6MnCMJGTHIpnmhACKhgKUZVko3w/N2oeOVZhKcNr2w05vd3jeTWDEaaw2SmHFEZrIfKsSBXLf1mQEynKBGSFk2YKtmGmBkJqQYgMslMmPftzzTTINQzeSFHKKaNE3XgBqZKY/vYjgzco4kZMQgq5nSJ4+fXTMXnzvLmOGVVKIG0VDAclVoP0Da00x+B+flip8+M4ON3cjorzTbxQAcyPz8kZRmKqgBOGXOuRrunhm7Adir/466rwy2CBbBr0TKGnGU1UyMzAw5FDOk7JAG4PSV3LxpY3Bhun9EKmVWMwUDmiWtYz9AqpVQo6vCsnSy0PgxAA82zjRTLh2AdVmCLdNMHh2ER1KaSRWq9sGRflEjZoWooCkF7PtW2OPzqH+fQxaZkZ4Z4357ZGa4fxfDmdI4chJSQFQDsEAejCzdaTVUR0I40pOAprlM5lUOmKIpWTGocJmaPdTYrzBzKs1OmZ1SNcUz48ZIqmZqrInimtOn5pUuVLN/omNuYLh7Znw0zQOG1jMj+8ykbNVMjkGTw/u7GM6UxpGTkAKiGoAF4uCTUqqZjMiMsUy2fifHNRdPzIgDc0BzVlQNFW5TsrOhjjNI2aqZ/Jg6yx1N0/Cdy2bn9RpqZEZEIL2qf4YLjmomH2km+1DYYmMvzQ7YPDPmoEmKmaFieP8VEOKC2gFYYKm0Ua6uqtKRELv5V3DBseNRWxFyTIguJOK9S2nAnDMy46c02/iZdEsz0TNTENw8GcFhfgJ1CGePVE2Fpc/M4O43mkwzWSOOzj4zPKUOFYzMkLLDbJrnkmZKWdNMwsdgL8sW/OTTcxFPpjzFTiEQr10q5l/AxceQUwdgOCIzXmJoJFUzFQI3T8Zw92k4q5l8RGaGKM2UkEZfpH8aN0RkZpjrymENjySk7DA9M+buLdNMyqDJYMAshfYSK4GAVlQhAwBN6Y6+E+qK39nXL/YrTF9iJr2ImmYyr2CZZioEbrPBhrtPIxjQoH4sT+E7COMMvPBKM9k9M4zMDB2lcylISIHIFJmxN3QThtuhPKke3VSDh//hFMxsHDVk62DHHurPadCk0mdG9OOgZ6Zw2EdDDPfIDGCI3XgWD5ClmmmwIzPpt+tPuXtmzDTToK4WUaCYIWWHjMyEVAOw8dNIMxm3A5pZml3s6Es2zjl63JC+v528qpl03RxnIPvMeF1t0zOTK0GbmBnunhnAEM9ifr13NVPQ9fZg4FWaHbIbgBmZGTK45UlZoeu60jRPNQArkRnVACzTTPxTUPE7yVhFmqxT5qDJbKXZjMzkjj0SUw6RmbCyH/jZVwbfM2Ns44StNNsZmRn+38VwhUcSUlYkkuaJVI3MmD1QzHEGgYCGUVmqmUYqTgOw/zSTbjEAi6Z5FDOFwu6bGe6eGcAa0fASZ0PrmTF+Jj08M3GKmSGHRxJSVoi5TIA1MqMO6BPVTEFNkyML1FbzJP80UzLl3WfG2vyM2z1XyjEyE1HEsmdkJjyU1UxpA7AszTbuF4Zf0wA8/L+L4QrFDCkrRFtxe0dfcTVrr2a68LgmnPfBcfj0aVMHf2VLmIE0zRMH+JQOlz4z5kFeLUFnZCZ37BUz5XACVdOapVjNpEkxI0qwrX1m7IZ3MvjQAEzKCrVhntqATvVzqH1mmkdX4heLTxn09Sx1BtI0L6BEv8zSbPF880RUFQ2irdu4PZLGGRQKNRITDGgl02gxH1TTbykOmpRpJls1kz3FVw5m7OEKjySkrBDhXrsHRlwxGSda475y8BoUC/u8HC/Pi4o44Ou28nfAKmbU+VOMzOSOKjTLJRKgpiFL0zNj7TNjr2YSlEPKb7jCIwkpK8RcJvtJUkQNdEuaiQceL+xXmHZx44baZ8aeZlIjMJZJ5SzNzpmgLTJTDoR8eWZKoc+M1ehr3/68QBo6KGZIWeE2MRuwHmRES3K3bqrEYCBN80zPjHPQpHrFqpqtGZnJHXVblkskQBUwXn1mxN+0pnk3YSwWIpWX8KhmEpTL9zEc4ZGElBWy+2/IPc0EKPNVeBXlicMz40N0iO2p6zB9SYEsaSb298kZS2SmTDwaauTPKwoohG+2CffFwOmZMX63b/9yiZQNR3gkIWWF21wmwAwTA+bVFVuPe+NompdDmgkA0tF41zSTaFQIMM00EMrRM2M1ALt/JjHhXhXDg0VQVjNZRbo9EkMxM3SwmomUFdIzYzcAB5yRGea3vbEfpMMh/03zANNb4DY1OxoKIhjQkEzprGYaAOXombGmmdz3iZmN1fjHD83AB8YN/gwzWZptO3bYy+SZZho6KGZIWaGWZqu4eWbK5URQDOxXx776zCiL2EtYw7Y+IpFgAL2pJD0zA6A8PTOKAdjjM2mahls/csxgrZIFczaTtxcMoA9vKOGRhJQVfR6l2daogTVUTJzYB+blmmZKJL37zISDAVSmTcCV7ACcM2XpmfERmRlKxCb3mpotKBdxORxhZIaUFaIDsKPPjHKQ6bdVJBAnRjM2s8TaX5rJvG0Px0ds1SpfWHgUNu3rwMzGwU8ZDHfK0zOTvZppKBEXPvb92umZKT0hNlKgmCFlhYzMONJM5u04q5l8EQ4E5LbKZTYT4LyCVcVQOBDAZ8+aXshVHVGUpWcmYN0/Sg3NHplJr6J9+5dgUGnEwE1PyoqYNABbd21N0+QByewzM6irNuxQD9S5zGYCnN4CP31EiD+sE6bLYye2e6pKDadnJh2ZcZRml8f3MRzhlidlhVefGUAprxSl2YzMZMTalTXXaibhmRHheKtnhgyccozM+JnNNJQE7BdCHtVMJajDRgylt9cQkgdiNpNbMzZxAIqzmskXoRwjM27iULxEREkz0SSZH+UoZoZLZKY/SzVTsASF2EiBW56UFSIy49aMTVxEcZyBP0I+hv+puAW6xMnWXs1EBk55ihlV7Jbe/uEUM6xmKjVKb68hJA9iHoMmAWu7ffV34k5IChHNV/t41Zck8OozQwZOOfaZCZX4/mFOzbZeCDkiMzymDBkUM6SskGkmFzFjL8VmaXZmhI8hl0iKfZu69ZkpRU/EcKI8IzOlvX+IzZzSrb87q5nK4/sYjpTeXkNIHsg0k0szNntaqQSj2SWFCPfnJmbsv7v0meEBPy/KUsyUeLTJcexwMbYD5fN9DEd4OCdlhRAzEZcTMK+iciPk4nfJhj0d5dpnpgSvvIcT5ShmQiXuqXKkTwPunply+T6GI6W31xCSB7FEpmom6+/Mb2cmqHhm/OKMzCD9GuwzUyjK0TMT9jE1eyjxSlHb17Vcvo/hCMUMKSsyVjPZD0g88GRECJD8PDNuaSYedvJB7W1SLk3aLAbxEvxMXiLdHonhMWXoKL29hpA8MMWMjzQTIzMZGVhkxn4Fi/RrmN9HxMecJ+KNqi1LMCMzIEo9cmffr4PSM8PITKlQJn8KZCSw61APbvvzBuxo6/ZcJpdqJua3MxMeUDWT/XdnOJ6Rmfwox3EGoRJPM9m9YJpHnxkeU4aO8vhLICOCR9fsxG9W78DvX93puYw5m8m7aZ6AgZnMuDW8y4azYsz5GqV4shpOlKMBWI3+Dec0U7l8H8OR0ttrCPGgs68fANAd6/dcJmOaiZGZnDA9M/mnmSIlXq0ynChPA7CxTwQDWkn6TrxEi6NpXgmu+0iBRxUybOhLVyqJ6IsbGdNM9MzkxEBKs73STNZ29dzu+aDux6V44h8IIl1WqvuGd5rJPmiyNNd/JEAxQ4YNvWkRI6IvbmRsmsdqppwIDqBpnlefmWBAc+0GTHKnHCMzwhReqvuGV5rJYQBmCnXIKM09hxAXZGQmHX2xo+s64rmkmXgVlRHTADzwPjNiE2uaNqBSb+KkHD0zMjJTomLAq3jAmX7ivj1UcMuTYYMpZtwjM+r9ftJMjMxkZkAG4Azzr8R3EnH5boh/yjEyI0RMqVZneVbpMXVdMoSGegUI8Us2z4xVzLilmay/l8tVbbEoRNM8dRN/6fxZ2NLaiWljqwqyfiOVcvTMRAZgNh9MnJ4Z4yermUoHihkybOjNkmYS92ua+0HR0a2Tx52MDKRpnmOGjXLHZ8+aXpD1GumUY2Smqa4CmgY0j64c6lVxxXOcAQdNlgwUM2TY0JfFACx7zIQCjispIHMKhDgZSNM8+8Gcm7jwlOM4g0n1VXjqi2djfG10qFfFFa+objDIyEypQDFDhg29cX+eGbcUE8A0U67IyEwOHhdVIGqaMzxP8qccIzMAcGxz7VCvgifOmWPGT44zKB3KQ9aTEYFII2VLM7mZfwHOZsoVEUIP53CAVjcpt29xKEfPTKnjlT6lZ6Z0oJghwwYRmYlni8yE3Xdr9pnJjYHNZtJcb5PCUa6RmVLG60KIXcVLB4oZMizQdR19/X49M15ppvLrz1FMzv3geMxsrMZ5x4z3/Rx1s1LLFIdy7DNT6nhV6QUCmmWf5/cxdNAzQ4YFiaSOZEoH4F6aret6TmkmpkCyM3/mWKy4+ZycnsPITPEJUpQPOs5mkGp0LIB40jgm8fsYOihmyLCgT/HJxPqT0HVdHlBWvLMfX/zPdTg/HUHwEjNWr0ERV3YEo1nEzBCuSBkT4pyrQcduZHdEx9KHJ34fQwfFDBkWiIZ5AJDSgf6ULj0dn/31awCA/3lzLwB/1UyMGhQHbuPiwzTT4JOpGWSIhuySgNenZFjQF7emloRvZuPeDseyXgZgS3ieJ9qiYC/NJoWHBuDBJ1OaKchIWUlAMUOGBX22cuxYOlLzhzU7Hcv6SzPxoFMMuI2Lj8WXxG08KHgNmgSsAoaRsqGDYoYMC0RZtiDWn4Ku6/jTG3sdy/pJM/GgUxyYZio+9MwMPs4+M+ZtFhaUBhQzZFigemYAQ8wkkjraexOOZf1UM/FEWxwCNAAXnXIcZ1DqZBqFErJ8H9zphwr+JZBBozeeRCLp3iMm63MdYiYpS7Xt+Gmal0MfOJIDjMwUH3pmBp9MYkYImADHdwwpPKSTQaE71o9jbvsrFt2/akDP77P1loklUuhPuQsjrzQTw8HFR2OfmaJDz8zgYw+AuVUz2Sdok8GFW58MCm/uOgIA2N7WM6Dnu6WZ+pNmZEY9uHgagC2VNjwJFANrZGbo1qOcoWdm8Mk0CkXcZoppaKGYIQWhP2kYcr1IeKSE/OIUM0n0p19T04Ax1VH5GMcZDB0UjMWHfWYGH+fUbKeg5HcxtFDMkLzpivXj7H9Zic//7nXPZZIeKSG/ODwziZT0zIQCGkZXheVjnn1mAuptHniKgTUFMoQrUsbQMzP42Dez20gJHlOGlqIdbrZv347PfvazmD59OiorKzFz5kzcfvvtiMfjluV27tyJSy+9FNXV1WhoaMBNN93kWGb9+vVYsGABKisrMXHiRNx1110ZowBkcHnyzb3Y196Hv77d4rlMIplvZMbZNC+hzEMZXamIGR9pJh53ioNmSTNxIxcDemYGH3uU0c0zQzEztBRtnMGmTZuQSqXw05/+FEcddRQ2bNiA6667Dt3d3bj33nsBAMlkEhdffDEaGxvx4osvoq2tDddeey10XccDDzwAAOjo6MCiRYuwcOFCrFmzBps3b8bixYtRXV2Nm2++uVirT3KgrTuedRmvyiO/ZKpmCgcC1siMV5qJ4fmiw/L34kPPzOBj38xuKWseU4aWoomZiy66CBdddJH8fcaMGXj33Xfx4IMPSjGzbNkybNy4Ebt27UJzczMA4L777sPixYuxdOlS1NbW4pFHHkFfXx8efvhhRKNRzJ49G5s3b8b999+PJUuWMC9fArR1mWImkUwh7FL3PNCSbEHMzQCcFjPBoIa6yoh8LOLVZ4aVNkWH4wyKDzvODj6ZDMCiionCcmgZ1Kx2e3s7xowZI39fvXo1Zs+eLYUMAFx44YWIxWJYu3atXGbBggWIRqOWZfbu3Yvt27e7vk8sFkNHR4flPykMz2zcj/f2d1ruO9Qdk7ftERSBGpkZSIrQ6ZlJytJsh2fGM81k3uZJoDiwz0zxURvlsRx4cMg0aNLsM8P9fSgZtL+E999/Hw888ACuv/56eV9LSwvGjx9vWa6+vh6RSAQtLS2ey4jfxTJ27rnnHtTV1cn/kydPLuRHGbGs3XEIn/vNa1j0b89b7j/QpYiZuLuY6beImdzfO1NpdigQ8OeZYQqk6FgG8HEbFwWr+XQIV2QE4RxnoERm0mk/Nf1HBp+c/xTuuOMOaJqW8f9rr71mec7evXtx0UUX4eMf/zg+97nPWR5zSxPpum65376MuLL3SjHdcsstaG9vl/937dqV68ckLmzY4x7h2nO4V972FDOKATg1oMiM0wAsoj1BRzWTR9M8GieLjrpZqWWKgzqlmeMMBgd7JNfNf0fxPrTk7Jm58cYbceWVV2ZcZtq0afL23r17sXDhQsyfPx8/+9nPLMs1NTXhlVdesdx3+PBhJBIJGX1pampyRGBaW1sBwBGxEUSjUUtaihQGNxNvKqVj75E++btXmknt1jsQK7CIzERDAcT6U+k+M+k0U1BDbY6RGV5EFYcAfUlFh6XZg0+mNBOrmUqDnMVMQ0MDGhoafC27Z88eLFy4EHPnzsWvfvUrBGxXEfPnz8fSpUuxb98+TJgwAYBhCo5Go5g7d65c5tZbb0U8HkckEpHLNDc3W0QTKT5uEZUDXTHEFXNvT5EiM0LMjK4KY39HzBhnkFT7zJgGYD+l2TzwFAf2mSk+bJo3+LCaqfQp2uFm7969OOecczB58mTce++9OHDgAFpaWixRlgsuuADHHnssrrnmGqxbtw4rVqzAV77yFVx33XWora0FAFx99dWIRqNYvHgxNmzYgCeeeAJ33303K5mGALfIzG4lxQQ4vS0CS2QmD89MXToCo6aZnJ4Zr9lM5m1GDYoD+8wUH7eGbaS4OPvMOKuZ+F0MLUUrzV62bBm2bNmCLVu2YNKkSZbHhOclGAziqaeewg033IAzzzwTlZWVuPrqq2XpNgDU1dVh+fLl+MIXvoB58+ahvr4eS5YswZIlS4q16sSDpIsK2X3YOmvJMzKTtwHYEEOj0yXY6jgDp2eGkZmhguMMio/VM8NtPBg4IzPmbfEdMOU3tBRNzCxevBiLFy/OutyUKVPw5JNPZlzm+OOPx/PPP59xGVJ8Ui6RmT1HrJEZT89M3gZg43VrlciMiPaEg5oUOQDTTEOJtWneEK5IGUPPzODj9MxwNlOpwaw28Y1b3zt7mqk33u/6XDUyk49nRqaZFM9MMKChpiKEqkgQAQ2oqQi7vga70xYfppmKDz0zg499X3b7DvhdDC1Fi8yQ8sNNhLQpPWYA79LsZIGqmUQ6SR1nEAoEEAhoePDTc9HV1y8Fjx1GDYoP518VH3pmBh+7Lld/F/1l+F0MLRQzxDduYsaeeerxkWbSBzDZQHhmVANwQoiZ9MFkwazGjK+hHoB44CkO1j4z3MbFIBjQoGmG94wdgAcHe18qVjOVHhQzxDf9Lp4ZYeaOhAKI96fQ58cAPIDYTK8jMpOS0R6/BxHOZio+loM8t3FR0DQN/3j2DLR1x9EwKpL9CSRv7IeYoMW3JKqZKCyHEooZ4hu3yIy4qzoSRLw/laHPjBmOyXWAdiJplmGbkZmkpc+MH+g1KD5qNIbH9uJxy0eOGepVGFHYhblblJdm7KGFhxviG7dqJiFwqqOGLvaqZkrkYQBWBZLFACzTTP52Y+uJlgeeYsBBk6QcydxnhoMmSwGKGeIbt2qmlIzMZBEz/QNvmidMxaJqCQDiSUXM+E4zqbd54CkG7DNDyhE/HYAZmRlaKGaIb1zTTOmfVVGj665XNVMiqYqZXCMzRrl3VTgou/vGEikkkzl6ZphmKjrWyMzQrQchhcRZmm3eZp+Z0oBihvjGbZyBECZZIzOWpnm5va9IM1VGgqhId/dVOwCHB5BmYtCgOKjpO4bdSblg35c1S2SG4wxKAYoZ4hu3cQamZ8aImHgZgNVhlG7VTK0dfXjoha040hN3PCYEUnU0ZEZm+lOWcQZ+sERmeKItCuwzQ8oRzXamtKaZjJ9MMw0trGYivnE1AKc1iojMeA2aTGSpZvrUQ6/gvdYuvLW7HT+4ao7lMRmZCQflqALroMncS7N5FVUc2GeGlCOONJPyuyhKEH4+MjRw6xPfuKaZ0lGWqiyRGYuYcXmd91q7AAAvbjnoeKwnlvbMREzPTDKlS+EUCvo7aVpa7VPMFAVGZkg5Yt+X1WPJZXMmIpHU8eHjmwZ3pYgFihniGzXNpOs6NE1zVjN5pZn6/bX9bRwVddynembUidhdaZHjtwsq00zFx1L+zm1MyoRMgyZrKsL4zFnTB3uViA16ZohvUimniVcYgKuyGIDjPqdmN9a4iJn0a1ZFghazr1qy7QdWMxWfAKNfpAyx63IeP0oPihniG0WPSEEiIzPZSrMz9JlRfTZuYkZM4q6OhBAMaPJAIiI2fj0zjBoUnwC3MSlD7JFcapnSg2KG+EaNzOgZIjNunhirAdj6eGuHOXlbiCIVNc0EAJF0dEaKGZ+emSD9HEWHfWZIOZKpNJuUBhQzxDeqCPGKzABGpZGdTNVM+9p75W23LsMi2lOVFjPhtHgRER2/A97UdjQMExcHRr9IOcI0U+lDMTOCae9N4NMPvYLfrt7ua/mkj8gM4O6bUZvmwdZnpqWjT3kPp5rpTqeZKtPvEQmJyilhAB5AmokHo6KgHuSpZUi5oGmatRqS+3bJQTEzgrnzf9/Gi1sO4tt/ftvX8hYxA2tkJhTQZA8YITJU4hkjM6aY6XdJUfXYIjORoM0zM4A0E6uZigMHTZJyhX6w0oZiZgTz+Ot7clremmYyfgpRo2mmp8WtcV4mz0xLuxqZcYoZe5opkhZNIgLku2legJGZYqPRl0TKFFbqlTYUMyOUA52m6TbsM7LhWs2U1igBTUNV2LtxXjxDNZPqmckcmQml19dqAPbrmQmwz0zR4dUrKVco1EsbipkRyv+93SJvj6up8PUcSzVTWpsIUaNpQEXEuzzbd2QmmUNkJn2/XzGmHoB8zqYkOcJxBqRcYQq1tOEhfYSyfON+eTvhVkLkgptnRuiSgKZJsdFjSzPpum4xADsjM6pnxrkuPQlhABbVTFZvju+meTQAFx23AXyElAPqvk0tU3rwcDNC2dHWLW+7+VTcSGbzzKTTTH22yEzCFm1RxUwimcKBLjPl5ZpmiqUjM2FrZEY1H/tBFTC8sioOGq9eSZkSYAFBSUMxMwLRdR37lUZ1fiMz1nEG1mqmgKbJ0mm7Z8b++mqa6XB33CJu3ISV3TMTsV3y+53NxINR8aFnhpQrTDOVNhQzI5COvn5LLxi3aIgb/S59ZqRnBkBlegikPc1kFzPqu3XbhE+/i2emJ25NM4nIjMB3abbyNKaZioPVMzN060FIoWFkt7ShmBmBtCpN6gB3AeGGtWmezTMT0KSXpd8mXuIZIjN2s7BraXZaHIkuw3bDr1/PjDUy4+spJEeCPOCTMsUSdeSZs+TgVzICER1366vCAICEi+nWDbeRBELUBDTTu2IXJE7PjCJmEtYGe3YDcCKZks+vCls7AAsGlGZiZKYosHyVlCtMM5U2FDMjEOGXmVhfCcCIrrgNh7TTn6EDsKZpst+LXczEbbOaVI+M3V9jf676eGXEPTLDpnmlAz0zpFzh3LHShmJmBLI/HZmZOLpS3ucnOpO0GIDFT9MzIzwpdg+O0wBs3raLGftz1flLwisTtXlmgr77zNAAXGzYZ4aUK9YOwEO3HsQdfiUjEFPMVMn7/PhmLGmmlLPPjIjM2KM89shMLp4ZIXZEVAYw+8zI3313AFZu80RbFAJMM5EyhVHH0oZiZgQixUy9GZnxI2bcljE9M5rvyIxbmqkmGnJ9rhA71cpUbntpNpvmlQ7sM0PKFYqZ0oZiZgTSIjwzSprJrfOunf4MfWY0zTTi2scVZDIAizRSTYUhVrwiM1VqZGaApdmW2Uzc84tCgIKRlClWoT5060Hc4SF9BCJKs5vqKmRUw0+vGVXwODwzmnkiyxqZUW6LyEtNRdjxHoCzxwzg1jQvd88Mr6yKgzWVN3TrQUihEcdKTaMfrBShmBlhJFM6WtMTs5tqK6QQ8NMFOGmZr5T2zKR/D2iajJA4qpky9JkRDfZEZMaeyrIPmQRcmub59MwEWZpddCgYSbki9mfu16VJKPsipJxo644hmdKhaUDDqAjCwQBi/Sl/BmCXyIzqmRF/5I4+Mw4DMLBu52GMioakWKmtFJEZ63O7pQE4f8+MqnlYzVQcaAAm5YrYtXnsKE0oZkYYrWm/TMOoKELBgIym+PLMuERmrJ4Zf5GZtq4Yrv3lqwCAT8ybBMDbM9ObTjOJIZOAMzJj7zvjBf0cxcc6WZjbmJQPYt/mbl2aMM00whATqhtHRQGYAiSbZ0bXdVvTPIOU0gE46NkB2CpmDnSaQy4P9yQAqGkmu2cmnWaKepdm+65mYqv9osMuqaRcEfs29+vShGJmhCF6vlSkh0IKv0m2NJNdoKRss5mMDsAeBuB+6+8VSpRFlIkLA7CfaqaBemas4wx8PYXkCMcZkHJFHD/otytNeEgfYYgoiYhuiDRTNgOwXaCIrFTK0mdGSz/m3wC8r12IGfc+M6KaqUrxzDjGGfiems3ITLFhZIaUKxrTTCUNxcwIQ4gWEd2Qk66zpJnsj4vZTDIyA3hHZmxiRo2+HEynvbwiMyINNTo9FBNwjjPwX5pt3ubVVXGwemaGcEUIKTBMM5U2FDMjDJHyESJGCpAsaSa7l0WIGDUyI0SFs2me9bkW7036Zq0SmVGb6rWlxU5DdVTeN1DPjKVpHg9IRYEjI0i5YpZmD/GKEFcoZkYYcZlmMv4iTQNwjmkmh2cmU9M86+/26AtgppmM1zbvb+uOAwDGjorI+xyeGZ8GGI4zKD6axZfEbUzKB7E7c78uTShmRhh2z4xMM2WNzNhHEhg/ZWQmoDbNswoj+6BJt/cSaSbAKqzauoSY8Y7MDKQDMA9IxYF9Zki5Ii6A2HKgNKGYGWFIz0zOBmB3E6/qmfFsmmf3zOhOMTMqakZmxPN1XUdbt5FmGlvtHZkZSNM8pkCKQ5B9ZkiZwjRTaUMxM8IQKR9pAA74NAAn7Wkm8dPpmXE0zeu3G4CdwklNM4l16Ykn0ZcwlrWkmWyRGXukxosgowZFh9VMpFyRaSbu1yUJxcwII9ZvTTP5HTTp9NTYZzP5b5rn9l5qmknMgBIppspw0FKabY/M+BUmTDMVH/aZIeWKWZrNHbsUoZgpMXYd6sHHf/ISlm/cX5TX9+ozY69WsuM0AIufYmq2d9O8uD2q4yJm1DSTmAF1UKSYlKiMuu6A4Zfxe3BRTb+MGhQHRmZIuSJLs3nWLEn4tZQYz20+gDXbD+OJdbuL8vpi6GM4ZPxlDtQAnEqXUKvVTMEBlGYDRt+YYMCZpnIz/wLWyIzfhnkCsY6MzBQHVTBSy5ByQnYA5o5dklDMlBjJ9InfzxTrgeAwAKdPPokcS7N1mOZfwNoB2L7umZrmAeaoAjNKJMSM6DFjj8yYBxO/owzM9TR+UswUB0ZmSLliGoC5X5ciFDMlhpm+Kc7ri5SPvTTbrfeLij0NldJ1qM8IKFOz7ZEZuxByihkjxSSEiYzMpHvMjLGJmWjQnNOUqyjhAam4WDwzPLqQMkLs2jx0lCY83JQYZslzcSMzdgOwvbGd83nOPjOqaNE0zbNpnl0I2cVMZToyY/fceKWZRIrM+BxMM5US1j4z3MakfOCgydKGYqbEsDejKzQJewdgnwZgt6nZVjEDpWmeXcxki8yk00x2z0zaANxgMwCrpdm5HljOPKoB08ZWYUJdRU7PI/5gmomUK5zNVNqEsi9CBhMhEIqVZhJiJppjnxm7p0bX3Twz7imrRJY0U2XYHpkx3suMzFjFTDCgQdOM98/VM/Oza+ZC1znOoFgwMkPKFXF8Yml2acLITImRlGKmOGom3u9emp2tA3DS0TRPt4kZ0+XvjMxkrmbyisyIidpjq61pJk3THB2M/aJpGoVMEeE4A1KuaDLNNMQrQlzh11JiFDvNZDcAe3XttWNvmufwzEDzbJrnMADrdjFjBAiDIuWVXv6Qy5BJQcTm+SGlgRoo4xUsKSeYZiptKGZKDNFQLkul9IAx+8yIyIbxM2cDMJyeGU8xk47MiIOBPcpTKSMzZpoqldJNMWOLzABmrxm/QybJ4MDIDClXxL5NkV6aUMyUGPbOuoXG7DOTpwE4ZfX1qH1m7JEXEWkRAsQeqXF4ZpI6uuL9crn66jDsmNVY3IVLCRqASbliNs0b4hUhrvBMUER2H+7BltaunJ5jn0ZdaOyl2b4NwC59ZmD3zHg2zbOmtuxCzc0zE0sPmNQ052BJQBmUySNLScE+M6Rc0ZhmKmlYzVREzvr+SgDAum8vQn210/fhhjjR26MbhcLhmfFrAHbpAGzvM+PlvxFTsoUosQsnMZdJrWaK9Sflc9zCukLM0DNTWqgHeobjSTnBhpulDa+dBoEdh3p8L5sqcjWTY9CkTwOwvbxat/WZCWjmH7kjzZS0pplUcfPRE5tx2ZyJlnXpT+qy6ioact9F7etPSgOmmUi5IvZt7talCSMzRULt4JvNj6JS7HEG0jOTowHYOc7AkmUyIjMeTfNEjxrpmUm/1+yJtfjBVXPkciElchPrF88Jwg3TAEw9XkqoAoYD+Ug5wQ7ApQ3PBEVCPZ/HcxIzRR5n0G9N+YRsjeq8cKSZlNJs+/BGrw7A9jlQ9it39fnZIjN2AzMpDdQePjzmk3JC7NuMOJYmFDNFQj2hZ4t6qBS/z4wozTb+IIXAyDal2/4Z1KZ5spmUR9M8uwE4qbuLmZDFM5NFzNAzU5KoXwc9M6ScYJqptKGYKRKpAaaZhBDI4Sk5Ye8AbB8h4IXb1Gy/kRnTI2N93H5QcIvMRLJ6ZrgLlxLsM0PKFaaZShueCYqEGljJJTJT/KnZaTNu0FranC0y41a67YjMZEkz2T0z3pEZXVYzeaeZaAAuRdSvlGMjSDmhsZqppCmqmPnoRz+KKVOmoKKiAhMmTMA111yDvXv3WpbZuXMnLr30UlRXV6OhoQE33XQT4vG4ZZn169djwYIFqKysxMSJE3HXXXcV7WRfKNSKnmxlzyqDNzXbGtmwVyvZsUdu3CIzsjLKtu52A7B8nm3vUwdVmp4ZdwOw6GAcpGempGBkhpQr5jiDoV0P4k5RxczChQvxxz/+Ee+++y4ee+wxvP/++7jiiivk48lkEhdffDG6u7vx4osv4tFHH8Vjjz2Gm2++WS7T0dGBRYsWobm5GWvWrMEDDzyAe++9F/fff38xVz1vLGmmHGYTFHNqdiqlywhLOMcOwPbITCqlRGaQvmJRIjPWai6rZ6bfwwBsjcxkTjNFZdM/HllKCfaZIeUK+8yUNkUtzf7yl78sb0+dOhXf+MY3cNlllyGRSCAcDmPZsmXYuHEjdu3ahebmZgDAfffdh8WLF2Pp0qWora3FI488gr6+Pjz88MOIRqOYPXs2Nm/ejPvvvx9Lliwp2QOmrmiDRH/uaaZiRGYSiqgyO+j6MwDbH1eb5tkjM4AhaEJBDbpuCqiIrZrJ/t2JKEsymfLdZ4bjDEoL9pkh5QoHTZY2g3YmOHToEB555BGcccYZCIeNWTurV6/G7NmzpZABgAsvvBCxWAxr166VyyxYsADRaNSyzN69e7F9+3bX94rFYujo6LD8H2zUVEsupdli0VQRQjOqd6cQBmDxEd2MceLzq/6ZcMgqZuxBFTfPjFdkhoMmSxONaSZSpkjPDK+fSpKify1f//rXUV1djbFjx2Lnzp3485//LB9raWnB+PHjLcvX19cjEomgpaXFcxnxu1jGzj333IO6ujr5f/LkyYX8SL5IDdgzU7w0k+gxAyizmYKmgMiE/XG1A7A4fwVtkRn78+yRmUx9ZrKVZtvHMZDSgJEZUq4wzVTa5Cxm7rjjDmialvH/a6+9Jpf/6le/inXr1mHZsmUIBoP4f//v/1n8FG5pIl3XLffbl9F19zSF4JZbbkF7e7v8v2vXrlw/Zt6oYibWPxDPTOHVjIgQBQPmhGtpAM41zaSbgstezQSYgkUVck4xY32PXDwzjMyUJuo+wIM+KSeYZiptcvbM3HjjjbjyyiszLjNt2jR5u6GhAQ0NDZg1axaOOeYYTJ48GS+//DLmz5+PpqYmvPLKK5bnHj58GIlEQkZfmpqaHBGY1tZWAHBEbATRaNSSlhoK1KxNPCcxY/wsRjGT2WPG/GMcsAFYN0Wl7DOjuURm1NRWyBoFckZmTP+OEHNe1UynzRiD3728A6fNGJtxvcngYqlmYjielBFCqPP6qTTJWcwIcTIQxMkvFosBAObPn4+lS5di3759mDBhAgBg2bJliEajmDt3rlzm1ltvRTweRyQSkcs0NzdbRFOpYY3MJHN+XlEMwLaybMCMzGQbNOlWmi2e4eqZcUkzme+VsjxPEJZN9VJyurdXZGbh0ePw1u0XsJdJiaExzUTKFNMzw/26FCnatdOrr76KH/7wh3jjjTewY8cOrFy5EldffTVmzpyJ+fPnAwAuuOACHHvssbjmmmuwbt06rFixAl/5yldw3XXXoba2FgBw9dVXIxqNYvHixdiwYQOeeOIJ3H333SVdyQRYxUEskUNkRnYALp4BOKKKmbSASGQ1AHtXM4mvQdM0edViihkzGqTZHnP2mTEjN9mqmYznl+73P1JhnxlSrjDNVNoUTcxUVlbi8ccfx3nnnYejjz4an/nMZzB79mysWrVKpoCCwSCeeuopVFRU4Mwzz8QnPvEJXHbZZbj33nvl69TV1WH58uXYvXs35s2bhxtuuAFLlizBkiVLirXqBUENrOTmmbH+LCRukZmwktrJhD0yo+u6TKWpolJGX3RrmikUCMiDgFdpdshiAM5czURKE/aZIeWKaQAe4hUhrhStz8zxxx+PZ599NutyU6ZMwZNPPpn1tZ5//vlCrdqgkG+aqRgdjoUBWBUIMjKTowE4lXJ2AAbS0ZakubwQUKGgGbXJ6pnx0QGYlCasZiLlCiMzpQ0vewtAfzLlKL9ODrCaqZjjDBIuBmCzNDs3A7D6W8AtMmPzzISDAXml7iaCjOc6S7MZmRlesM8MKVfomSlteKbIE13X8bEf/Q0X/vvzFp+LGlnJyTNTzD4ztrECgDIPKUtkxi6uUrrimVHul71ibGmmYMD0zCQ8Bk2qDfz8eGZIacIrWFKOHDVulPGzcdQQrwlxo6jjDEYCiaSOt/caHYY7+xIYXWVUXKliJLcOwGkxUxQDsEuaKeDPAKyafXVdNM1D+j7zpGWfnC0NwAFNznAS2M919MyUBwFNQ0rXHd8vIcOZS09sxqnTx2BczdC2/SDu8EyRJ2rEQo3MWKqZcvLMOF+3UMT6XQzAPmczic8jBIdlarayF9nFjIjChIIBR9rBEZmRPW90KQAZmRl+1FWGEdCAUVFeK5HyYnxtBY3tJQqPNnliETCKAEkNMM1U1HEGyQxN89KTrr3+UEXgJhjQkEjq6eiMcZ8qSoK2iqV+iwHY+toZPTMJipnhyoOfnosjPXEZpSSEkGJDMZMnqmhRgykDL80e3KZ5YSWsIiZdZ1qvcCCAPqQsHYBdPTO2fjkhxTMjyFjN5JISI8ODU6ePGepVIISMMHimyBPValLINFMxxhlIz4xqAFbES6ZhkyLqJJZPKZ6ZgItnRrxWQoqZgCPqk7HPTIKl2YQQQvxBMZMnSQ/PTL6DJpNFUDNuIwLUQY2ZpnunbJ4ZwNkBWH3cnmYKK31mBPbfLdVMjMwQQgjxCc8UeeKVZlKDHAMrzS5mnxmnARjIbAIWn0f0kUmldFfPTCCDAdhezeQ1m6k/qSOWMKJZ9MwQQgjJBs8UeZLyYwDOJc2U1j2i/LmQuHlmLP1fMpRnC3ESlNVMimcmU2Qm/ZqhgJ/IDD0zhBBCcodnijzxTDMpt+MDSDMBhffNmH1mvL0q2dZLGIR1ZPbMiO0iDcBBFwNwgJ4ZQggh+UMxkyfq+V+3RGbM+wcyzsB4jcKqmbhLmgkwU0eZ00wukRk4B0aa1UzGeyWUQZN2w2+mDsAxRmYIIYT4hGeKPPGTZupP6dIImw1LpKfQYsZlnAGgDpvMnmYSpdy6pZrJXM4UM8bvVgOwvz4z/Umd4wwIIYT4hmeKPPEqx7ZHVfyONBiMNJNdzMguwBnSTGJdhFjRdfdqJrNpXjoyYynNtr6mV2SmN2F6jBiZIYQQkg2eKfJEFR9ePWcA/xVNqSKlmd4/0IUjPQkAQCTo7lXJlGZK2jwzKV2XaTVXz0z64ybTN4IupdmOPjPp1+6Jm2KGkRlCCCHZYAfgPEl5pJbsOsSvb8bLd5MP63e349Ifvih/t0c7QopXxQvnbCbzM7p5ZsRr9cv0VPY0k6hm6on3m+sapJghhBCSGZ4p8kTNHnl5ZgD/5dle4igfnnu31fK70zNj/J7IEJkRqyLMwtZqJnO5TIMm7djFjRBKPTFzYjaHuhFCCMkGxUyeWNNM7v4ZwH95tiqOUgUKzUxvrLb87mUAzmRStveZsXhm1NfK2AE4W2QmLWZEwzxGZQghhPiAZ4s8sZp+4XobGNo0k73zbtiWZgoHshuAHZ6ZVDbPjNtsJtt6ZZjNBADRMHdPQggh2eHZIk/UyIwqbOzde4cyzWQv8bYbgO3DId0Qn0cIDh1wHWfgbJqXkvc7IzPu62GuJ3dPQggh2eHZIk+8qo/sAmIoq5ns6SpnaXYuaaaAXDf5shk8M/2yt032cQbCjyOIhtn9lxBCSHYoZvLEq7fMQNNMqvDIUFyUE3b/jt2M68cALJvmBZ2eGasBOGBZ3mIAtkdm7OMMgozMEEIIyR2eLfJkOKaZDnTGLL/boyluOJvm6YqYUdJM6Zv2QZNhl0GTdg9NyLYAPTOEEEL8wLNFnnhFZhxN8/xGZgYhzTS5vtLyu+zam+H9kjbPjPqSVs+MNTIjfDihYMBhRKZnhhBCSCFg07w88eoAPOA0UxHGGQghMrOxGtcvmInzjxlveVwOj8xUzaSIErGeruMM0vqjX3pmVAOw9TWze2YoZgghhGSHYiZPUr6b5vktzVZeu8CRmVnja/DxeZMdjwdySDOp1Uzis2uZIjMWA3CWyAw9M4QQQgYAzxZ5YhEwKffbABBL+PPMeA2uzAfxOnbDrUD6XHykmdw9M+Zy9l4xap8ZOCIz7n1mBNEQq5kIIYRkh2ImT7wqmAqRZipU0zxRpBT0GA3gJ80k1kuUdadSRnQGyNw0byAdgAWcmE0IIcQPPFvkiWWEQQHSTKqesFdEDRSxjnaxIAhkMQDruu6sZoLZAVh9VXvTvH753gGnZ8Z2R21FGDVRM/NJMUMIIcQPPFvkSdIjtTTQQZPFGGeQlOmgzJEZr7SWer9azSTudpuabY/MhIJa1nEGkVAAHz2pWf4epZghhBDiA54t8sSrlNrpmRlImqnAnhmPAdTZxIx6t5zN5OGZcYgZpdletjQTAFx5yhR5uzfuTwASQggZ2VDM5IlXbxl7M12/aaZiGIB1m3nXTnYxoyvLpncZ3WM2k2Z9rYSIzAScu5pbpGj2xFp5u9XW3I8QQghxg2ImT7ya5tn9LpnmHqmoTytYn5n0W3tXM5nRFvfnu6WZFM+MS2RGdP7NXJrtfC9N0/Drz5yKmY3V+PKiWZk+FiGEEAKAfWbyxruaySoMMpU9e79eYccZeFUzmX1msq+TmWYyP68qUkK211INwEnbsCm7Z0awYFYjVtx8jsenIYQQQqwwMpMnnmkmmzDwmzIq5jgDzzRTlsiMqkHUyIxbB2BTGKUjMylvA7CXIZkQQgjJBYqZPElaRhh4R1X8i5nBr2bK1gE46eKZ0eHumXFEZkSaya00m1qGEEJIAaCYyROvCia7Z8ZvlKUYaSYzMuP+uLjfjwFYjjPwnM1kjcwkLKXZmccZEEIIIQOBYiZPUh4VTPY0U7+9vMnr9dQ006CNM8iWZjJFi3iJVMqjmkk2zbO+dyhgn5kNR9qJEEIIGQgUM3niOZtJtv/PLBTsFDPNlN0AnLnPTFAzoyt6+h/gHpk50NmH/31zL3rSvWJCwUDWQZOEEELIQGA1U554GXZ1KWYCSCSTvjwz6tgA9TXyXkefBuBsnpmAZpZXWzoAwxmZeXnrIby89ZC8PxSgAZgQQkhxYGQmT7xmMyUVMQOYJcqZsGuXQRtnEMwSmZFpKjMK4zU12yv6E3aJzHh5eAghhJBc4OkkT7xnMxk/c0kz2XvR+O1Nk/V10/6drJEZL8+MkqYKSDGT2TNjx89sJkIIIWQgUMzkSbameTIy48MAbBc8g9ZnRvSOyTJoMqB4ZtQOwOqkAtFUz46RZqJnhhBCSOGhmMkTr6Z5QhgIMeNHmNgXKZRnJmufGZ+RmYBSkaR6ZqB4ZrzewzAA2983+7oTQggh2aCYyRPvpnnGz3AWP4qKIzLjb5xT9tfN2mcm2zgDc7mArGaCq2fGbaAkAIQDbrOZqGYIIYTkD8VMnng1ubOnmfyJGe/XzoesBmDfaSYzpWQYgOF4XS/BFAoG2GeGEEJIUaCYyRNLNVPKeb8UM34MwDYxUTAxk8Uzky3NZPHMQDE0u1UzeURmgvTMEEIIKRIUM3mS9IzMGD/NNFP213KOQMh//dT18jYAp5fzeENdSTOZpdlKnxkfkZkwB00SQggpEhQzeeI1fsDeZybpwwBTtDRTKnOaKWtkxrVpntdsJvddKhRw6wDs8wMQQgghGaCYyROvpnn6gDwzxYnMZO0zk77fq7GfOdvJFC5qNZPb1Gw74aDmEC/sM0MIIaQQUMzkiedsprSAMJvmZX8tu5gp2DiDLLOZQlkMwLryfClcdMjZTKpI8Yr+aJpbmsnX6hNCCCEZoZjJE6+mec5xBj7STLZF/ERz/JBtana2QZNqmkpOzVbmSKkRFrVp3tHjayyv4zAAU80QQggpABQzeeKVZrKXZvvpGVOsNJNbPxiVoOKDcX++8TMQsHYAFp9d84jMnDp9jOV16JkhhBBSDDg1O0/cyrEBswJIpJl8RWaKNc4gSzVTtsiMKobEKxhN89LP9/DMfHh2E2orQ5hcXwUALn1mqGYIIYTkD8VMnniNMxC3TQNw9tcq2jiDLNVM5qDJ7M83q5ncPTOqYGqoieKrF35Q/s4OwIQQQooB00x5knXQZMj/bKaipZl8VjN5GYDVyI7aAVh6ZhwxF4Ox1RHL7zQAE0IIKQYUM3liGS6pO9NMETk1O3toxp7mKZgBONugSd9pJrMDsNE0zxmZ6ehNyNujq7KJGaoZQggh+UMxkyeWCiaXNJMse/ZVmm39vdBpJs/ITNZxBsbPgNIB2No0z3zdGY2jzNcNZE4rUcwQQggpBPTM5EnKIzJjTzP5ibIUf5yB++PZxhmYfWpg9czI0mxz2aa6Ciz78odQVxl2vI4jMkMpTQghpABQzORJ9tlMJTA12+c4A68OwCnl+eZsJvep2QAwy9Zfxv4+Xr8TQgghA4HXxnniVc0kIzOBzCkcr9cyfi/EGmZPM4Vkl+Iss5kCZjWTMTQ7c/8aO/blaAAmhBBSCChm8sSaZlLud0kzZfPA2KM3XmmfnNcxyzgDOWjSM80E+fxsnpnMWJdjnxlCCCGFgGImT9TeLG7CJqwYVbJpE7vWKXiaKUtptqeYUQdNwoziuHlmMuGMzFDMEEIIyR+KmTyxpJlchk5GlFlF2XwzxRtnYPzMVs3kPc7AOZvJqwNwJhyzmahlCCGEFACKmTzJlmYKKZGZ3MXMIBmAfQ6aNJrmFdIzQzVDCCEkfyhm8sRi+s0wzgDIbgIesj4zWXrhWJvmmfeJxf2KEvty1DKEEEIKwaCImVgshpNOOgmapuGNN96wPLZz505ceumlqK6uRkNDA2666SbE43HLMuvXr8eCBQtQWVmJiRMn4q677irYiT5fvJrm2QdN2h93fy17B+D810993XwNwEZptrMD8EBhZIYQQkghGJQ+M1/72tfQ3NyMN99803J/MpnExRdfjMbGRrz44otoa2vDtddeC13X8cADDwAAOjo6sGjRIixcuBBr1qzB5s2bsXjxYlRXV+Pmm28ejNXPiFujPPV2xCXN9OU/vIH3D3Thsc+fYTUI26uZCm4Adn88mwHYTFOZqaJUhj4zXtgNyBQzhBBCCkHRxczTTz+NZcuW4bHHHsPTTz9teWzZsmXYuHEjdu3ahebmZgDAfffdh8WLF2Pp0qWora3FI488gr6+Pjz88MOIRqOYPXs2Nm/ejPvvvx9LliwZ8vJer9lMIqWkpnaSKR3JlI4n1u0BAKzf046Tp9Qrz7e+dqGiTymXdVHxawAOBtwjM+wzQwghZCgpappp//79uO666/Db3/4WVVVVjsdXr16N2bNnSyEDABdeeCFisRjWrl0rl1mwYAGi0ahlmb1792L79u2u7xuLxdDR0WH5Xyy8m+YZP4MBTfGk6DjUbabQqiNWLVmscQbSM+NpADZ+Zu0AHFCqmXQdwjTjVfJtxz5de6iFKCGEkPKgaGJG13UsXrwY119/PebNm+e6TEtLC8aPH2+5r76+HpFIBC0tLZ7LiN/FMnbuuece1NXVyf+TJ0/O9+N44jbCAFArfTQpIvpTOg50xlyfa3++2+MDJVufmVBazXg16Usq6SR1NpNsmudzPRiZIYQQUgxyFjN33HEHtLQR1Ov/a6+9hgceeAAdHR245ZZbMr6e29W5ruuW++3LCKHgdWV/yy23oL29Xf7ftWtXrh/TN55pJjWaoQxyPNBlipn+pFU82Kud/IxA8IPawdcNYdvxer+UjOyorzmADsC2xbzSXoQQQkgu5OyZufHGG3HllVdmXGbatGn47ne/i5dfftmSHgKAefPm4VOf+hR+/etfo6mpCa+88orl8cOHDyORSMjoS1NTkyMC09raCgCOiI0gGo063rdYeFUzmeZYEflIIWmLzCRS1nIleySmUAVb2Uqzs1czucxmQu5N85yl2RQzhBBC8idnMdPQ0ICGhoasy/3gBz/Ad7/7Xfn73r17ceGFF+IPf/gDTjvtNADA/PnzsXTpUuzbtw8TJkwAYJiCo9Eo5s6dK5e59dZbEY/HEYlE5DLNzc2YNm1arqtfcLya5qlpJqEh7Gkme2TG4ZkpkGkmKSMo7o9LT49nmkn5LOkojq6MM/BvAGYHYEIIIYWnaJ6ZKVOmYPbs2fL/rFmzAAAzZ87EpEmTAAAXXHABjj32WFxzzTVYt24dVqxYga985Su47rrrUFtbCwC4+uqrEY1GsXjxYmzYsAFPPPEE7r777pKoZALcRxgA1q67ogtwSreLGVtkxtZXplAGYF33GZnJmmbSlNlMarrP33rYF2NpNiGEkEIwpB2Ag8EgnnrqKVRUVODMM8/EJz7xCVx22WW499575TJ1dXVYvnw5du/ejXnz5uGGG27AkiVLsGTJkiFccxNLmsmlz4zRmyVtAE5aPTOJLH1lCm0A9vbMiMiM+/NlOslWzZSrZ8YZmaGYIYQQkj+D0jQPMHw0bn1TpkyZgieffDLjc48//ng8//zzxVq1vEh5GIB1RQAIg60RmemTyzgiM0UQM7ra3C7b1GyP91Ob5gnhYlQzpV/X76BJm3SmliGEEFIIOJspTzxnMyk+E1H67DAAJ+3iBbbf8xcz6msOdJyBmqZSOwCbs5n8rQvTTIQQQooBxUyeuHX9Ve8PaNamdKqYsYuHbH1nBoL6HtkiM4C7CVgVZjKlNADPDA3AhBBCigHFTJ5YmuYpWSNxW22a1xtPoqOvXy7T7yjNtr52IcYZqOuXbZyBsU4uYkb5LNbZTKbI8YN9MUZmCCGEFAKKmTzxapqnzjMSImJ/R5/luY40k01IZJuynev6eRqAlW54bqktM81kCpCUbgq2gRqAqWUIIYQUAoqZPFHP/W7CRtPMiEiLTcxkNwDnv35q6stzaraiKtwElFpmLtDT/wD/4wxU8aJpbJpHCCGkMFDM5InVJ6Pcn9YpRmTG2MyOyIzDMwPb7wVIM/mIzKgix62iSXpmApr03QyomkmRPUwxEUIIKRQUM3nilWayDJpMb+WW9twiM4VoM2NJM/nwzLgZgMV6BDVrnxldMTn7QV2O5l9CCCGFgmImT7KlmQKaKRYOdcctz806zqAAakYdZeCV1lFFTuY0kxld0ZXIzEA8M0wxEUIIKRQUM3mSdWq2ZhqAexNJy3PtgyZtgZqCGIDFW3ilmACkp52n3zNbmkntM5PrOANGZgghhBQBipk88ZrNpCt+Ei8xY4/MFCXNpAiRTAix4zbSQFYzKX1mBuSZUZbLJK4IIYSQXKCYyRO3rr8ALD1YxMk+lrAqBbtnphhpJnVIZCYCGUYayChTQLNEV1I5emYAMzpDAzAhhJBCQTGTJ9beMub9ZkQECAW90kzFr2aSQyZ9R2ac76lGYFQR4laynQ2xLLUMIYSQQkExkydes5ncBEBv3J5mGrw+M9miJ0LsuHUAltGdgPV15GfPQZiI52dLexFCCCF+oZjJE7doDGAtzQ6lT9x9/YaYEVEJewdgx6ymghiAfUZmRJop22wmRbnkOs4AMKuhmGYihBBSKChm8sTaW8YUMabPxBQKYtGqcNCyjPp8r9ceKEKI+BUzbu+pRpk0ZY/pT/mL+qiYnhn/zyGEEEIyQTGTJ87J19afdp8JAFRFQwDcBk0WIc3k09ciHneLzKjRHfV1Unl5ZqhmCCGEFAaKmTyxC5BkSrdUJQU0TRqABVURIzLjGDSZ/jWUIUqS8/opYxUyIboUZ2+aZyIiM7nIEkZmCCGEFBqKmTxxq0CyT6q2Ry4q02kmLwOwED8F7TOTJRIiq5lc00xq0zxnZCaXKIt4Pj0zhBBCCgXFTJ4400y6ReBoAWdUpFJEZjwMv+H05MeCdABWSsQzEchgAFaNvqoGGZBnRrwfxQwhhJACQTGTB27VRsmUboluBJUOwAKRZnJGZtLPCRYyzeSvaV4mA3BSeQ3Xpnk5qBnxfGoZQgghhYJiJg9cUzIp6/0BTXMIicpw2gDsMc4gFChgminlT3AEpQHY+Zg0Mwfcm+blokvEejAyQwghpFBQzOSBW+t/R5pJc6aZqqPuaSbdVkZd0NJsv+MMMqaZrCKkfwCeGTPN5PsphBBCSEZCQ70Cwxm3oYxJXUdANQAHck8zhdIGl0GtZspQmq2ORFBfJTUAzwwNwIQQQgoNIzN54J5mcpZmOwzAHmmmpK2aKVmINJPfaqYMgya9DMBi2ZwiM5zNRAghpMBQzOSB+4nfWq4dcEkzyT4zHk3zTM/M4I8zcB00mV5NQ8yYgiY5kGomzfp+hBBCSL5QzORBypZOAgyBI42xmhGJcBiAZZrJfZxBIdNMfg3AfjwzorGeeCWzNDuXPjPiJ8UMIYSQwkAxkwfqeT+kRDZ0W2rHYQCWHYBtkRlbFMXNk5MrpgE483Licbdokz1VJX6KRXPRJcJ1w3EGhBBCCgXFTB6oUQx1BIE5l8n46UwzhRzPN56bfq1i9JnJK83kLmYEWg7F2WZkxvdTCCGEkIxQzOSBpWRZSdPYIxleHYD7HWLG6pkpZGm270GTGaZmi89hf6ls3YVVNFYzEUIIKTAUM3lgekk0S2+YbJGMKq80k6xmEp6Z/NcxmWNkJuOgSS8xk1M1k3iO76cQQgghGaGYyYOkIlrECT2lm14SccIOeUVmsnQALkiaSc8xzZSxNBvpn9bXGkifGXpmCCGEFAqKmTxQS5ZlmkZNM4nW/R6emX5HabbxUwiLwowzMNcxE+b6Ox+TgsgzRUTPDCGEkKGDYiYPrGkm4z510KQ46dsjM2aayX2cQThYyA7AuaaZnGrGLDVPR1Vsj+fWZ4aeGUIIIYWFYiYPkqoBWClXts9YUoVEMKAhkhYr9nEGdn+Lm39l4OvoV8w4H8tqAB6QZ4ZihhBCSGGgmMmDlGKMVauBzNSO+GmeuMNBTZZe2wdNil/DwUKmmawN77wIZqxmsr6GPW2Wk5gRP6llCCGEFAiKmTyQEQtl/pKaZhIplVBQFTMBmUZyDpoUoqGAaaZcDcAZqpm80ky5CBMOmiSEEFJoKGbyIGmJzBj36co4AzfDbCQYUKqVrOLBHGdQwD4zPkcOZBpnoCuize21BiRmuOcRQggpEDyl5IFX0zx7abYaFQkHA7KPDGAdNukszc5/HX33mdGs65DpNexl1fTMEEIIGUooZvJALVlWPSf2NJMqJCKhgPTEANZeM0I0yHEGBVAz9rJqLzJFZpLy88DyUz43JzHDPjOEEEIKC8VMHiRdDMC6rgx3FNVMdgOwkmNRxUxxpmYbP7OJh0wGYHt1lj3Ik1uaSbyf/+cQQgghmaCYyQO1n4w1zWTtmGtPM1kiMy5ppmAB00z2SiQv/BiAC+GZYZqJEEJIoaGYyQO1/4psmmeZmu2eZtKU6id12GRRxhn49MyYYsz5WPamebl0AGaaiRBCSGGhmMkDs1JIbZqnOwYz2iMzgClY1GGTQtcIg3BB+sz4bZonxxk41YyuiDbAKURykSViWY4zIIQQUigoZvJAnY6tzjayD2a0RGbSQsXsNaNEZlLWyEwhOgDnPM7ArZrJPpvJttcMxADMNBMhhJBCQTGTB9Y0k1tptosBOJSOzARFmsmlNFtUMxXCAFyAcQZmmsn4XbPFYnJLM6V/cs8jhBBSIHhKyQNVKLg1zXP1zKSFiqhYUodNyjRTEaZm++4A7FrNZF3GUc2Uw17E0mxCCCGFhmImD9QUjjqbSaaZ0lvXzTMjKposaSYZmRn8cQZmmsw7zeQ1iiAXWeI2r4oQQgjJB4qZPFC9MRnTTC5iRtyndgAeynEGshorQ2m2TA0VoGkeDcCEEEIKBcVMHng2zUt5RzLCGQzA9rEBKd1sWJfvOvqdmm0XUOr7e/WZGcjUbEZmCCGEFAqKmTxQRwWoTfPs1Uzq1OxIyFqa3Z90MwCbX0u+wZl8xxmovwc8oioDGTRJLUMIIaRQUMzkgdocT+gVtWmeaZh1MQCnBUsiw9Rs4z0KE5kJZDMAe0RmVG0jXsNezcQOwIQQQoYSipk8UL0k4uScSjkHTYYyGoC9p2Yb9+W3jvlGZlRxYzbNsz13AB2A6ZkhhBBSKChm8kCtFAooPpdMTfPCtjRTwrWaaQgiMy7jFdTnA96VSLkZgHN/DiGEEJIJipk8UAdNqlOn7UZeNwOwSDOpYiEp01Pm15K/mBGv6TPNlCEyI6Mqjg7A/teHfWYIIYQUGoqZPBBCwZiabdxOuZRmq5GWaMiWZrKUZhtPDA9BmskcZ2B7fsq5jNMzk3sH4GzVVYQQQohfeErJA7emeSnd6ZmxRmYydQB2Nrgb7DSTPTKTdIvMKC+Va4DFq/EeIYQQMlAoZvLAq2meTDO5eWYyGYBT1mUAQHeZlZQL5pDIzMv5MQCLj6FGYnIVJewzQwghpNBQzOSBdTaTGZlxpJlcxIyMzKQyR2bcpljngu+p2Yrnx+35AU31u5iP51qV5PYahBBCSD5QzOSBe5oJzjSTZdCkbWq2S2n20KSZ0u/nkWYKeERj7P6ZbLCaiRBCSKGhmMkD2TQvoFlmG8nUTvo+NTITkQZg5zgDtQmfONfnK2Z895nxiswon9Fc1nw8d8+M8zUIIYSQfKCYyQN1BpO1aR7k/epPQE0zpfvMpNwjM0J85DvOwP+gSQ/PjJJmEqjRmFwjLDQAE0IIKTQUM3mQUsy1atM83ZaasRqAreMM1MiM6bWBxYOT3zqmX9NvNZPt/Uwzs5JayiMyI5ZnnxlCCCGFgmImD2Q1U8C9aZ4QEG4dgN2qmcTzNCXNZI+UDHQds/V1EeKpP2lPMzk9N17+GT+Y5eo5PY0QQgjxhGImDyxN84THxZJmMn4GXQzAQZlmclYzqZGZwU4zOQdNOp+fT2SGaSZCCCGFhmImD1RzbUARA7rNdBt08cyYBmC1A7Dx0yKOClTNlLU027PPjPVxsX5ut/1g9pnJ6WmEEEKIJxQzeZBKZU4zaS6emYiPQZP2wZV5raPfcQZy/a33u0V28ovMiOdRzRBCCCkMRRUz06ZNS/s/zP/f+MY3LMvs3LkTl156Kaqrq9HQ0ICbbroJ8Xjcssz69euxYMECVFZWYuLEibjrrrtk9GMoSappIWUcQKY0k90AnHRJM2kFNADnPc7ArZqpIJ4ZihlCCCGFIVTsN7jrrrtw3XXXyd9HjRolbyeTSVx88cVobGzEiy++iLa2Nlx77bXQdR0PPPAAAKCjowOLFi3CwoULsWbNGmzevBmLFy9GdXU1br755mKvfkayNc0zp2abzxGeGTFMUh006eXByQc5iTtbnxmPNJPummaC620/mE3zcnseIYQQ4kXRxUxNTQ2amppcH1u2bBk2btyIXbt2obm5GQBw3333YfHixVi6dClqa2vxyCOPoK+vDw8//DCi0Shmz56NzZs34/7778eSJUtc0xWxWAyxWEz+3tHRUZTPpvaTEdVCq99vQ0XY+MVs3a8hGNCQTOlmn5n0z9e2H8ad//s2AKArlpCvJ8TRj1ZuQX11ZMDruOdwDwD/4wz2tffK9QGAg11xuU4Ca8ppgH1mqGYIIYQUiKKLme9///v4zne+g8mTJ+PjH/84vvrVryISMU7Oq1evxuzZs6WQAYALL7wQsVgMa9euxcKFC7F69WosWLAA0WjUsswtt9yC7du3Y/r06Y73vOeee3DnnXcW+6NZWv3XVoQBABv3mcKpttLcvHWVYRzuiaO20lhudJXx873WLrzX2mV53ZqKEGorw2jrjuNPb+wtyLqK9/WiLv344Z4EfvW37RmfX1MRcr3tB7F8bY7PI4QQQrwo6hnln//5n3HyySejvr4er776Km655RZs27YNDz30EACgpaUF48ePtzynvr4ekUgELS0tcplp06ZZlhHPaWlpcRUzt9xyC5YsWSJ/7+jowOTJkwv50QAA82eMRUAD5k6tx9ypY6AD6OwzoiuV4SA+ecoUueyPP3UyjvTEMSYdZfnoic3o6uvHkV6rP2jW+Bo0j67E/Z84ESveaYWO/L1BzaMrMWfy6IzLzJ5Yi+9dfjx2pSM5Kho0XDTbjK595YKjMb2hGv1JHecfO96xfCY+v2AmZjRU4+9OnpTT8wghhBAvchYzd9xxR9aox5o1azBv3jx8+ctflvedcMIJqK+vxxVXXIHvf//7GDt2LAD3NIWu65b77cvouu56vyAajVoiOcXiQ7Ma8aFZjfL36xfM9Fz29BljLb9XR0O47kMzPJefM6Uec6bU57+SPtE0DVeeOiX7ggAmj6nCl86fNaD3GVdbgWvmTxvQcwkhhBA3chYzN954I6688sqMy9gjKYLTTz8dALBlyxaMHTsWTU1NeOWVVyzLHD58GIlEQkZfmpqaZJRG0NraCgCOqA4hhBBCRh45i5mGhgY0NDQM6M3WrVsHAJgwYQIAYP78+Vi6dCn27dsn71u2bBmi0Sjmzp0rl7n11lsRj8el12bZsmVobm72FE2EEEIIGTkUrc/M6tWr8W//9m944403sG3bNvzxj3/EP/3TP+GjH/0opkwx0hkXXHABjj32WFxzzTVYt24dVqxYga985Su47rrrUFtbCwC4+uqrEY1GsXjxYmzYsAFPPPEE7r77bs9KJkIIIYSMLIpmAI5Go/jDH/6AO++8E7FYDFOnTsV1112Hr33ta3KZYDCIp556CjfccAPOPPNMVFZW4uqrr8a9994rl6mrq8Py5cvxhS98AfPmzUN9fT2WLFliMfgSQgghZOSi6aXQSrfIdHR0oK6uDu3t7TLiQwghhJDSxu/5m7OZCCGEEDKsoZghhBBCyLCGYoYQQgghwxqKGUIIIYQMayhmCCGEEDKsoZghhBBCyLCGYoYQQgghwxqKGUIIIYQMa4rWAbiUEH0BOzo6hnhNCCGEEOIXcd7O1t93RIiZzs5OAMDkyZOHeE0IIYQQkiudnZ2oq6vzfHxEjDNIpVLYu3cvampqCj6csqOjA5MnT8auXbs4KiEL3Fb+4bbKDW4v/3Bb5Qa3l3+Ksa10XUdnZyeam5sRCHg7Y0ZEZCYQCGDSpElFfY/a2lru6D7htvIPt1VucHv5h9sqN7i9/FPobZUpIiOgAZgQQgghwxqKGUIIIYQMayhm8iQajeL2229HNBod6lUpebit/MNtlRvcXv7htsoNbi//DOW2GhEGYEIIIYSUL4zMEEIIIWRYQzFDCCGEkGENxQwhhBBChjUUM4QQQggZ1lDMEEIIIWRYQzGTBz/+8Y8xffp0VFRUYO7cuXjhhReGepWGnDvuuAOapln+NzU1ycd1Xccdd9yB5uZmVFZW4pxzzsHbb789hGs8uDz//PO49NJL0dzcDE3T8Kc//cnyuJ/tE4vF8MUvfhENDQ2orq7GRz/6UezevXsQP8XgkG1bLV682LGvnX766ZZlRsq2uueee3DKKaegpqYG48aNw2WXXYZ3333Xsgz3LQM/24r7lsmDDz6IE044QXb1nT9/Pp5++mn5eKnsVxQzA+QPf/gDvvSlL+Gb3/wm1q1bh7PPPhsf/vCHsXPnzqFetSHnuOOOw759++T/9evXy8f+5V/+Bffffz9++MMfYs2aNWhqasKiRYvkMNByp7u7GyeeeCJ++MMfuj7uZ/t86UtfwhNPPIFHH30UL774Irq6unDJJZcgmUwO1scYFLJtKwC46KKLLPvaX/7yF8vjI2VbrVq1Cl/4whfw8ssvY/ny5ejv78cFF1yA7u5uuQz3LQM/2wrgviWYNGkSvve97+G1117Da6+9hnPPPRcf+9jHpGApmf1KJwPi1FNP1a+//nrLfR/84Af1b3zjG0O0RqXB7bffrp944omuj6VSKb2pqUn/3ve+J+/r6+vT6+rq9J/85CeDtIalAwD9iSeekL/72T5HjhzRw+Gw/uijj8pl9uzZowcCAf2vf/3roK37YGPfVrqu69dee63+sY99zPM5I3Vb6bqut7a26gD0VatW6brOfSsT9m2l69y3slFfX68/9NBDJbVfMTIzAOLxONauXYsLLrjAcv8FF1yAl156aYjWqnR477330NzcjOnTp+PKK6/E1q1bAQDbtm1DS0uLZbtFo1EsWLCA2w3+ts/atWuRSCQsyzQ3N2P27Nkjchs+99xzGDduHGbNmoXrrrsOra2t8rGRvK3a29sBAGPGjAHAfSsT9m0l4L7lJJlM4tFHH0V3dzfmz59fUvsVxcwAOHjwIJLJJMaPH2+5f/z48WhpaRmitSoNTjvtNPzmN7/B//3f/+HnP/85WlpacMYZZ6CtrU1uG243d/xsn5aWFkQiEdTX13suM1L48Ic/jEceeQTPPvss7rvvPqxZswbnnnsuYrEYgJG7rXRdx5IlS3DWWWdh9uzZALhveeG2rQDuW3bWr1+PUaNGIRqN4vrrr8cTTzyBY489tqT2q1DBXmkEomma5Xdd1x33jTQ+/OEPy9vHH3885s+fj5kzZ+LXv/61NNBxu2VmINtnJG7DT37yk/L27NmzMW/ePEydOhVPPfUULr/8cs/nlfu2uvHGG/HWW2/hxRdfdDzGfcuK17bivmXl6KOPxhtvvIEjR47gsccew7XXXotVq1bJx0thv2JkZgA0NDQgGAw6VGVra6tDoY50qqurcfzxx+O9996TVU3cbu742T5NTU2Ix+M4fPiw5zIjlQkTJmDq1Kl47733AIzMbfXFL34R//M//4OVK1di0qRJ8n7uW068tpUbI33fikQiOOqoozBv3jzcc889OPHEE/Ef//EfJbVfUcwMgEgkgrlz52L58uWW+5cvX44zzjhjiNaqNInFYnjnnXcwYcIETJ8+HU1NTZbtFo/HsWrVKm43wNf2mTt3LsLhsGWZffv2YcOGDSN+G7a1tWHXrl2YMGECgJG1rXRdx4033ojHH38czz77LKZPn255nPuWSbZt5cZI3rfc0HUdsVistParglmJRxiPPvqoHg6H9V/84hf6xo0b9S996Ut6dXW1vn379qFetSHl5ptv1p977jl969at+ssvv6xfcsklek1Njdwu3/ve9/S6ujr98ccf19evX69fddVV+oQJE/SOjo4hXvPBobOzU1+3bp2+bt06HYB+//336+vWrdN37Nih67q/7XP99dfrkyZN0p955hn99ddf188991z9xBNP1Pv7+4fqYxWFTNuqs7NTv/nmm/WXXnpJ37Ztm75y5Up9/vz5+sSJE0fktvr85z+v19XV6c8995y+b98++b+np0cuw33LINu24r5l5ZZbbtGff/55fdu2bfpbb72l33rrrXogENCXLVum63rp7FcUM3nwox/9SJ86daoeiUT0k08+2VLaN1L55Cc/qU+YMEEPh8N6c3Ozfvnll+tvv/22fDyVSum333673tTUpEejUf1DH/qQvn79+iFc48Fl5cqVOgDH/2uvvVbXdX/bp7e3V7/xxhv1MWPG6JWVlfoll1yi79y5cwg+TXHJtK16enr0Cy64QG9sbNTD4bA+ZcoU/dprr3Vsh5Gyrdy2EwD9V7/6lVyG+5ZBtm3FfcvKZz7zGXmea2xs1M877zwpZHS9dPYrTdd1vXBxHkIIIYSQwYWeGUIIIYQMayhmCCGEEDKsoZghhBBCyLCGYoYQQgghwxqKGUIIIYQMayhmCCGEEDKsoZghhBBCyLCGYoYQQgghwxqKGUIIIYQMayhmCCGEEDKsoZghhBBCyLDm/wOemqrjbfyaAAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用Matplotlib绘制奖励值的曲线图\n",
    "plt.plot(episode_rewards)\n",
    "plt.title(\"reward\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5e2eed4c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 重置环境，开始新的一轮游戏\n",
    "observation, _ = env.reset()\n",
    "# 创建GymHelper对象来辅助显示\n",
    "gym_helper = GymHelper(env, figsize = (3, 3))\n",
    "\n",
    "# 开始游戏\n",
    "for i in range(500):\n",
    "    # 渲染环境，title为当前步骤数\n",
    "    gym_helper.render(title = str(i))\n",
    "    \n",
    "    # 找到当前状态下的最优动作\n",
    "    action = agent.choose_action(observation)\n",
    "    # 执行action，获取新的信息\n",
    "    observation, reward, terminated, truncated, info = env.step(action)\n",
    "    \n",
    "    # 如果游戏结束，则结束当前循环\n",
    "    if terminated or truncated:\n",
    "        break\n",
    "\n",
    "# 游戏结束\n",
    "gym_helper.render(title = \"Finished\")\n",
    "# 关闭环境\n",
    "env.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
